Upload 34 files

.env

@@ -0,0 +1,9 @@
+APP_NAME=StoryFlicks
+DEBUG=true
+VERSION=1.0.0
+
+text_provider="openai"
+image_provider="openai" 
+
+text_llm_model=comic-c
+image_llm_model=comic

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+resource/fonts/MicrosoftYaHeiBold.ttc filter=lfs diff=lfs merge=lfs -text
+resource/fonts/MicrosoftYaHeiNormal.ttc filter=lfs diff=lfs merge=lfs -text
+resource/fonts/STHeitiLight.ttc filter=lfs diff=lfs merge=lfs -text
+resource/fonts/STHeitiMedium.ttc filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,21 @@
+# 使用 Python 3.10 精简版镜像
+FROM python:3.10-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制项目的 requirements.txt
+COPY requirements.txt /app/
+
+# 配置 pip 使用阿里云镜像并安装依赖
+RUN pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/ \
+    && pip install --no-cache-dir -r requirements.txt
+
+# 复制整个后端项目到容器
+COPY . /app/
+
+# 设置环境变量
+ENV PYTHONUNBUFFERED=1
+
+# 设置默认的命令，启动 Uvicorn 服务
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

README.md

@@ -1,10 +1,11 @@
 ---
-title: Mp4
-emoji: 🌖
-colorFrom: yellow
+title: mp4
+emoji: 🌍
+colorFrom: blue
 colorTo: pink
 sdk: docker
 pinned: false
+license: mit
+app_port: 8000
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/api/__init__.py

@@ -0,0 +1 @@
+from app.api.router import router as api_router

app/api/health.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, status
+from app.schemas.health import HealthResponse
+from app.services.health import health_service
+
+router = APIRouter()
+
+
+@router.get(
+    "/",
+    response_model=HealthResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Health Check",
+    description="Check the health status of the application"
+)
+async def health_check():
+    """
+    健康检查接口
+    
+    返回:
+    - status: 整体状态 (healthy/degraded)
+    - version: 应用版本
+    """
+    return await health_service.check_health()

app/api/llm.py

@@ -0,0 +1,64 @@
+from fastapi import APIRouter, HTTPException
+from app.services.llm import llm_service
+from app.schemas.llm import (
+    StoryGenerationRequest,
+    StoryGenerationResponse,
+    ImageGenerationRequest,
+    ImageGenerationResponse,
+)
+from loguru import logger
+from enum import Enum
+from typing import List, Dict
+
+router = APIRouter()
+
+class LLMType(str, Enum):
+    TEXT = "text"
+    IMAGE = "image"
+    VIDEO = "video"
+
+
+@router.post("/story", response_model=StoryGenerationResponse)
+async def generate_story(request: StoryGenerationRequest) -> StoryGenerationResponse:
+    """生成故事"""
+    try:
+        segments = llm_service.generate_story(
+            request
+        )
+        return StoryGenerationResponse(segments=segments)
+    except Exception as e:
+        logger.error(f"Failed to generate story: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/image", response_model=ImageGenerationResponse)
+async def generate_image(request: ImageGenerationRequest) -> ImageGenerationResponse:
+    """生成图片"""
+    try:
+        image_url = llm_service.generate_image(prompt=request.prompt, image_llm_provider=request.image_llm_provider, image_llm_model=request.image_llm_model, resolution=request.resolution)
+        return ImageGenerationResponse(image_url=image_url)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/story-with-images", response_model=StoryGenerationResponse)
+async def generate_story_with_images(request: StoryGenerationRequest) -> StoryGenerationResponse:
+    """生成故事和配图"""
+    try:
+        segments = llm_service.generate_story_with_images(
+            segments=request.segments,
+            story_prompt=request.story_prompt,
+            language=request.language
+        )
+        return StoryGenerationResponse(segments=segments)
+    except Exception as e:
+        logger.error(f"Failed to generate story with images: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/providers", response_model=Dict[str, List[str]])
+async def get_llm_providers():
+    """
+    获取 LLM Provider 列表
+    """
+    # 这里将实现获取 LLM Provider 的逻辑
+    return llm_service.get_llm_providers()

app/api/router.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+from app.api import voice, video, llm
+
+router = APIRouter(prefix="/api")
+router.include_router(voice.router, prefix="/voice", tags=["voice"])
+router.include_router(video.router, prefix="/video", tags=["video"])
+router.include_router(llm.router, prefix="/llm", tags=["llm"])

app/api/stories.py

@@ -0,0 +1,57 @@
+from fastapi import APIRouter, HTTPException, Query
+from typing import List
+from ..schemas.story import Story, StoryCreate, StoryUpdate
+from ..services.story import story_service
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[Story])
+async def list_stories(
+    skip: int = Query(0, ge=0),
+    limit: int = Query(10, ge=1, le=100)
+):
+    """
+    获取故事列表
+    """
+    return story_service.get_stories(skip=skip, limit=limit)
+
+
+@router.post("/", response_model=Story)
+async def create_story(story: StoryCreate):
+    """
+    创建新故事
+    """
+    return story_service.create_story(story)
+
+
+@router.get("/{story_id}", response_model=Story)
+async def get_story(story_id: str):
+    """
+    获取特定故事的详细信息
+    """
+    story = story_service.get_story(story_id)
+    if story is None:
+        raise HTTPException(status_code=404, detail="Story not found")
+    return story
+
+
+@router.put("/{story_id}", response_model=Story)
+async def update_story(story_id: str, story: StoryUpdate):
+    """
+    更新故事信息
+    """
+    updated_story = story_service.update_story(story_id, story)
+    if updated_story is None:
+        raise HTTPException(status_code=404, detail="Story not found")
+    return updated_story
+
+
+@router.delete("/{story_id}")
+async def delete_story(story_id: str):
+    """
+    删除故事
+    """
+    if not story_service.delete_story(story_id):
+        raise HTTPException(status_code=404, detail="Story not found")
+    return {"message": "Story deleted successfully"}

app/api/video.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter, HTTPException, Query
+from loguru import logger
+from app.services.video import generate_video, create_video_with_scenes, generate_voice
+from app.schemas.video import VideoGenerateRequest, VideoGenerateResponse, StoryScene
+import os
+import json
+from app.utils.utils import extract_id
+
+router = APIRouter()
+
+@router.post("/generate")
+async def generate_video_endpoint(
+    request: VideoGenerateRequest
+):
+    """生成视频"""
+    try:
+        video_file = await generate_video(request)
+        task_id = extract_id(video_file)
+        # 转换为相对路径
+        video_url = "http://127.0.0.1:8000/tasks/" + task_id + "/video.mp4"
+        return VideoGenerateResponse(
+            success=True,
+            data={"video_url": video_url}
+        )
+    except Exception as e:
+        logger.error(f"Failed to generate video: {str(e)}")
+        return VideoGenerateResponse(
+            success=False,
+            message=str(e)
+        )
+
+

app/api/voice.py

@@ -0,0 +1,98 @@
+from fastapi import APIRouter, HTTPException, Request, Query
+from fastapi.responses import JSONResponse
+from app.schemas.voice import VoiceGenerationRequest, VoiceGenerationResponse
+from app.schemas.video import VideoGenerateResponse, StoryScene
+from app.services.voice import generate_voice, get_all_azure_voices
+from app.services.video import create_video_with_scenes
+import os
+import json
+from typing import List, Optional
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class VoiceRequest(BaseModel):
+    area: Optional[List[str]] = None
+
+
+@router.post("/test_subtitle")
+async def test_subtitle_endpoint(task_id: str = Query(..., description="任务ID，对应 storage/tasks/ 下的目录名")) -> VideoGenerateResponse:
+    """测试字幕添加功能"""
+    try:
+        # 构建任务目录路径
+        task_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "storage", "tasks", task_id)
+        if not os.path.exists(task_dir):
+            raise HTTPException(status_code=404, detail=f"Task directory not found: {task_id}")
+            
+        # 读取 story.json
+        story_file = os.path.join(task_dir, "story.json")
+        if not os.path.exists(story_file):
+            raise HTTPException(status_code=404, detail=f"Story file not found: {story_file}")
+            
+        with open(story_file, 'r', encoding='utf-8') as f:
+            scenes_data = json.load(f)
+        
+        # 转换为 StoryScene 对象
+        scenes = [StoryScene(**scene) for scene in scenes_data]
+        
+        # 生成语音和字幕
+        voice_name = "zh-CN-XiaoxiaoNeural"
+        voice_rate = 0
+        for i, scene in enumerate(scenes, 1):
+            audio_file = os.path.join(task_dir, f"{i}.mp3")
+            subtitle_file = os.path.join(task_dir, f"{i}.srt")
+            await generate_voice(scene.text, voice_name, voice_rate, audio_file, subtitle_file)
+        
+        # 创建视频
+        video_file = await create_video_with_scenes(task_dir, scenes, voice_name, voice_rate)
+        
+        video_url = "/" + video_file.split("/tasks/")[-1]
+        return VideoGenerateResponse(video_url=video_url, scenes=scenes)
+    except Exception as e:
+        logger.error(f"Failed to test subtitle: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/generate", response_model=VoiceGenerationResponse)
+async def generate_voice_api(request: Request) -> VoiceGenerationResponse:
+    """
+    生成语音和字幕文件
+    
+    Args:
+        request: 包含文本内容和语音配置的请求
+        
+    Returns:
+        生成的音频和字幕文件的URL
+    """
+    try:
+        # 手动解析请求体
+        body = await request.json()
+        req = VoiceGenerationRequest(**body)
+        
+        audio_file, subtitle_file = await generate_voice(
+            text=req.text,
+            voice_name=req.voice_name,
+            voice_rate=req.voice_rate
+        )
+        
+        if not audio_file or not subtitle_file:
+            raise HTTPException(status_code=500, detail="Failed to generate voice")
+            
+        # 将文件路径转换为URL路径
+        audio_url = f"/tasks/{os.path.basename(audio_file)}"
+        subtitle_url = f"/tasks/{os.path.basename(subtitle_file)}"
+        
+        return VoiceGenerationResponse(
+            audio_url=audio_url,
+            subtitle_url=subtitle_url
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/voices")
+async def list_voices(request: VoiceRequest) -> dict:
+    """
+    获取所有支持的语音列表
+    """
+    return {"voices": get_all_azure_voices(request.area)}

app/config.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from functools import lru_cache
+import os
+
+class Settings(BaseSettings):
+    app_name: str = "Story Flicks"
+    debug: bool = True
+    version: str = "1.0.0"
+    
+    # provider configuration
+    text_provider: str = "openai"
+    image_provider: str = "openai"
+
+    # base url configuration
+    openai_base_url: str = "https://api.openai.com/v1"
+    aliyun_base_url: str = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    deepseek_base_url: str = "https://api.deepseek.com/v1"
+    ollama_base_url: str = "http://localhost:11434/v1"
+    siliconflow_base_url: str = "https://api.siliconflow.cn/v1"
+
+    # api key
+    openai_api_key: str = ""
+    aliyun_api_key: str = ""
+    deepseek_api_key: str = ""
+    ollama_api_key: str = ""
+    siliconflow_api_key: str = ""
+
+    text_llm_model: str = "gpt-4o"
+    image_llm_model: str = "dall-e-3"
+
+    class Config:
+        env_file = ".env"
+        # env_file = os.path.join(os.path.dirname(os.path.dirname(__file__)), ".env")
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()

app/exceptions.py

@@ -0,0 +1,5 @@
+class LLMResponseValidationError(Exception):
+    """LLM 响应验证错误"""
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)

app/models/__init__.py

@@ -0,0 +1 @@
+

app/models/const.py

@@ -0,0 +1,60 @@
+from enum import Enum
+
+class StoryType(str, Enum):
+    """故事类型"""
+    custom = "custom"  # 自定义故事
+    bedtime = "bedtime"  # 睡前故事
+    fairy_tale = "fairy_tale"  # 童话故事
+    adventure = "adventure"  # 冒险故事
+    science = "science"  # 科普故事
+    moral = "moral"  # 寓言故事
+
+class ImageStyle(str, Enum):
+    """图片风格"""
+    realistic = "realistic"  # 写实风格
+    cartoon = "cartoon"  # 卡通风格
+    watercolor = "watercolor"  # 水彩风格
+    oil_painting = "oil_painting"  # 油画风格
+
+class Language(str, Enum):
+    """支持的语言"""
+    CHINESE_CN = "zh-CN"      # 中文（简体）
+    CHINESE_TW = "zh-TW"      # 中文（繁体）
+    ENGLISH_US = "en-US"      # 英语（美国）
+    JAPANESE = "ja-JP"        # 日语
+    KOREAN = "ko-KR"          # 韩语
+
+# 语言名称映射
+LANGUAGE_NAMES = {
+    Language.CHINESE_CN: "中文（简体）",
+    Language.CHINESE_TW: "中文（繁体）",
+    Language.ENGLISH_US: "English",
+    Language.JAPANESE: "日本語",
+    Language.KOREAN: "한국어"
+}
+
+PUNCTUATIONS = [
+    "?",
+    ",",
+    ".",
+    "、",
+    ";",
+    ":",
+    "!",
+    "…",
+    "？",
+    "，",
+    "。",
+    "、",
+    "；",
+    "：",
+    "！",
+    "...",
+]
+
+TASK_STATE_FAILED = -1
+TASK_STATE_COMPLETE = 1
+TASK_STATE_PROCESSING = 4
+
+FILE_TYPE_VIDEOS = ["mp4", "mov", "mkv", "webm"]
+FILE_TYPE_IMAGES = ["jpg", "jpeg", "png", "bmp"]

app/schemas/__init__.py

@@ -0,0 +1 @@
+

app/schemas/health.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel, Field
+from typing import Dict, Any
+
+
+class HealthResponse(BaseModel):
+    status: str = Field(..., description="Overall health status of the application")
+    version: str = Field(..., description="Application version")

app/schemas/llm.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any
+from app.models.const import Language
+from typing import Optional
+
+class StoryGenerationRequest(BaseModel):
+    resolution: Optional[str] = Field(default="1024*1024", description="分辨率")
+    text_llm_provider: Optional[str] = Field(default=None, description="Text LLM provider")
+    text_llm_model: Optional[str] = Field(default=None, description="Text LLM model")
+    image_llm_provider: Optional[str] = Field(default=None, description="Image LLM provider")
+    image_llm_model: Optional[str] = Field(default=None, description="Image LLM model")
+    segments: int = Field(..., ge=1, le=10, description="Number of story segments to generate")
+    story_prompt: str = Field(..., min_length=1, max_length=4000, description="Theme or topic of the story")
+    language: Language = Field(default=Language.CHINESE_CN, description="Story language")
+
+
+class StorySegment(BaseModel):
+    text: str = Field(..., description="Story text")
+    image_prompt: str = Field(..., description="Image generation prompt")
+    url: str = Field(None, description="Generated image URL")
+
+
+class StoryGenerationResponse(BaseModel):
+    segments: List[StorySegment] = Field(..., description="Generated story segments")
+
+
+class ImageGenerationRequest(BaseModel):
+    prompt: str = Field(..., min_length=1, max_length=4000, description="Description of the image to generate")
+    image_llm_provider: Optional[str] = Field(default=None, description="Image LLM provider")
+    image_llm_model: Optional[str] = Field(default=None, description="Image LLM model")
+    resolution: Optional[str] = Field(default="1024*1024", description="Image resolution")
+
+
+class ImageGenerationResponse(BaseModel):
+    image_url: str = Field(..., description="Generated image URL")

app/schemas/story.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+
+class StoryBase(BaseModel):
+    title: str
+    description: Optional[str] = None
+
+
+class StoryCreate(StoryBase):
+    pass
+
+
+class StoryUpdate(StoryBase):
+    title: Optional[str] = None
+
+
+class Story(StoryBase):
+    id: str
+    
+    class Config:
+        from_attributes = True

app/schemas/video.py

@@ -0,0 +1,318 @@
+import warnings
+from enum import Enum
+from typing import Any, List, Optional, Union, Dict
+
+import pydantic
+from pydantic import BaseModel, Field
+from app.models.const import Language
+
+# 忽略 Pydantic 的特定警告
+warnings.filterwarnings(
+    "ignore",
+    category=UserWarning,
+    message="Field name.*shadows an attribute in parent.*",
+)
+
+
+class VideoConcatMode(str, Enum):
+    random = "random"
+    sequential = "sequential"
+
+
+class VideoAspect(str, Enum):
+    landscape = "16:9"
+    portrait = "9:16"
+    square = "1:1"
+
+    def to_resolution(self):
+        if self == VideoAspect.landscape.value:
+            return 1920, 1080
+        elif self == VideoAspect.portrait.value:
+            return 1080, 1920
+        elif self == VideoAspect.square.value:
+            return 1080, 1080
+        return 1080, 1920
+
+
+class _Config:
+    arbitrary_types_allowed = True
+
+
+@pydantic.dataclasses.dataclass(config=_Config)
+class MaterialInfo:
+    provider: str = "pexels"
+    url: str = ""
+    duration: int = 0
+
+class VideoParams(BaseModel):
+    """
+    {
+      "video_subject": "",
+      "video_aspect": "横屏 16:9（西瓜视频）",
+      "voice_name": "女生-晓晓",
+      "bgm_name": "random",
+      "font_name": "STHeitiMedium 黑体-中",
+      "text_color": "#FFFFFF",
+      "font_size": 60,
+      "stroke_color": "#000000",
+      "stroke_width": 1.5
+    }
+    """
+
+    video_subject: str
+    video_script: str = ""  # Script used to generate the video
+    video_terms: Optional[str | list] = None  # Keywords used to generate the video
+    video_aspect: Optional[VideoAspect] = VideoAspect.portrait.value
+    video_concat_mode: Optional[VideoConcatMode] = VideoConcatMode.random.value
+    video_clip_duration: Optional[int] = 5
+    video_count: Optional[int] = 1
+
+    video_source: Optional[str] = "pexels"
+    video_materials: Optional[List[MaterialInfo]] = None  # Materials used to generate the video
+
+    video_language: Optional[str] = ""  # auto detect
+
+    voice_name: Optional[str] = ""
+    voice_volume: Optional[float] = 1.0
+    voice_rate: Optional[float] = 1.0
+    bgm_type: Optional[str] = "random"
+    bgm_file: Optional[str] = ""
+    bgm_volume: Optional[float] = 0.2
+
+    subtitle_enabled: Optional[bool] = True
+    subtitle_position: Optional[str] = "bottom"  # top, bottom, center
+    custom_position: float = 70.0
+    font_name: Optional[str] = "STHeitiMedium.ttc"
+    text_fore_color: Optional[str] = "#FFFFFF"
+    text_background_color: Union[bool, str] = True
+
+    font_size: int = 60
+    stroke_color: Optional[str] = "#000000"
+    stroke_width: float = 1.5
+    n_threads: Optional[int] = 2
+    paragraph_number: Optional[int] = 1
+
+
+class SubtitleRequest(BaseModel):
+    video_script: str
+    video_language: Optional[str] = ""
+    voice_name: Optional[str] = "zh-CN-XiaoxiaoNeural-Female"
+    voice_volume: Optional[float] = 1.0
+    voice_rate: Optional[float] = 1.2
+    bgm_type: Optional[str] = "random"
+    bgm_file: Optional[str] = ""
+    bgm_volume: Optional[float] = 0.2
+    subtitle_position: Optional[str] = "bottom"
+    font_name: Optional[str] = "STHeitiMedium.ttc"
+    text_fore_color: Optional[str] = "#FFFFFF"
+    text_background_color: Union[bool, str] = True
+    font_size: int = 60
+    stroke_color: Optional[str] = "#000000"
+    stroke_width: float = 1.5
+    video_source: Optional[str] = "local"
+    subtitle_enabled: Optional[str] = "true"
+
+
+class AudioRequest(BaseModel):
+    video_script: str
+    video_language: Optional[str] = ""
+    voice_name: Optional[str] = "zh-CN-XiaoxiaoNeural-Female"
+    voice_volume: Optional[float] = 1.0
+    voice_rate: Optional[float] = 1.2
+    bgm_type: Optional[str] = "random"
+    bgm_file: Optional[str] = ""
+    bgm_volume: Optional[float] = 0.2
+    video_source: Optional[str] = "local"
+
+
+class VideoScriptParams:
+    """
+    {
+      "video_subject": "春天的花海",
+      "video_language": "",
+      "paragraph_number": 1
+    }
+    """
+
+    video_subject: Optional[str] = "春天的花海"
+    video_language: Optional[str] = ""
+    paragraph_number: Optional[int] = 1
+
+
+class VideoTermsParams:
+    """
+    {
+      "video_subject": "",
+      "video_script": "",
+      "amount": 5
+    }
+    """
+
+    video_subject: Optional[str] = "春天的花海"
+    video_script: Optional[str] = (
+        "春天的花海，如诗如画般展现在眼前。万物复苏的季节里，大地披上了一袭绚丽多彩的盛装。金黄的迎春、粉嫩的樱花、洁白的梨花、艳丽的郁金香……"
+    )
+    amount: Optional[int] = 5
+
+
+class BaseResponse(BaseModel):
+    status: int = 200
+    message: Optional[str] = "success"
+    data: Any = None
+
+
+class TaskVideoRequest(VideoParams, BaseModel):
+    pass
+
+
+class TaskQueryRequest(BaseModel):
+    pass
+
+
+class VideoScriptRequest(VideoScriptParams, BaseModel):
+    pass
+
+
+class VideoTermsRequest(VideoTermsParams, BaseModel):
+    pass
+
+class TaskResponse(BaseResponse):
+    class TaskResponseData(BaseModel):
+        task_id: str
+
+    data: TaskResponseData
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "status": 200,
+                "message": "success",
+                "data": {"task_id": "6c85c8cc-a77a-42b9-bc30-947815aa0558"},
+            },
+        }
+
+
+class TaskQueryResponse(BaseResponse):
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "status": 200,
+                "message": "success",
+                "data": {
+                    "state": 1,
+                    "progress": 100,
+                    "videos": [
+                        "http://127.0.0.1:8080/tasks/6c85c8cc-a77a-42b9-bc30-947815aa0558/final-1.mp4"
+                    ],
+                    "combined_videos": [
+                        "http://127.0.0.1:8080/tasks/6c85c8cc-a77a-42b9-bc30-947815aa0558/combined-1.mp4"
+                    ],
+                },
+            },
+        }
+
+
+class TaskDeletionResponse(BaseResponse):
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "status": 200,
+                "message": "success",
+                "data": {
+                    "state": 1,
+                    "progress": 100,
+                    "videos": [
+                        "http://127.0.0.1:8080/tasks/6c85c8cc-a77a-42b9-bc30-947815aa0558/final-1.mp4"
+                    ],
+                    "combined_videos": [
+                        "http://127.0.0.1:8080/tasks/6c85c8cc-a77a-42b9-bc30-947815aa0558/combined-1.mp4"
+                    ],
+                },
+            },
+        }
+
+
+class VideoScriptResponse(BaseResponse):
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "status": 200,
+                "message": "success",
+                "data": {
+                    "video_script": "春天的花海，是大自然的一幅美丽画卷。在这个季节里，大地复苏，万物生长，花朵争相绽放，形成了一片五彩斑斓的花海..."
+                },
+            },
+        }
+
+
+class VideoTermsResponse(BaseResponse):
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "status": 200,
+                "message": "success",
+                "data": {"video_terms": ["sky", "tree"]},
+            },
+        }
+
+
+class BgmRetrieveResponse(BaseResponse):
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "status": 200,
+                "message": "success",
+                "data": {
+                    "files": [
+                        {
+                            "name": "output013.mp3",
+                            "size": 1891269,
+                            "file": "/MoneyPrinterTurbo/resource/songs/output013.mp3",
+                        }
+                    ]
+                },
+            },
+        }
+
+
+class BgmUploadResponse(BaseResponse):
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "status": 200,
+                "message": "success",
+                "data": {"file": "/MoneyPrinterTurbo/resource/songs/example.mp3"},
+            },
+        }
+
+
+from app.models.const import StoryType, ImageStyle
+
+class StoryScene(BaseModel):
+    """故事场景"""
+    text: str = Field(description="场景文本")
+    image_prompt: str = Field(description="图片生成提示词")
+    url: Optional[str] = Field(default=None, description="生成的图片 URL")
+
+class VideoGenerateRequest(BaseModel):
+    """视频生成请求"""
+    text_llm_provider: Optional[str] = Field(default=None, description="Text LLM provider")
+    image_llm_provider: Optional[str] = Field(default=None, description="Image LLM provider")
+    text_llm_model: Optional[str] = Field(default=None, description="Text LLM model")
+    image_llm_model: Optional[str] = Field(default=None, description="Image LLM model")
+    test_mode: bool = Field(default=False, description="是否为测试模式")
+    task_id: Optional[str] = Field(default=None, description="任务ID")
+    segments: int = Field(default=3, ge=1, le=10, description="分段数量")
+    language: Language = Field(default=Language.CHINESE_CN, description="故事语言")
+    story_prompt: Optional[str] = Field(default=None, description="故事提示词")
+    image_style: ImageStyle = Field(default=ImageStyle.realistic, description="图片风格")
+    voice_name: str = Field(default="zh-CN-XiaoxiaoNeural", description="语音名称")
+    voice_rate: float = Field(default=1.0, description="语音速率")
+    resolution: Optional[str] = Field(default="1024*1024", description="分辨率")
+
+
+class VideoGenerateResponse(BaseModel):
+    """视频生成响应"""
+    success: bool
+    data: Optional[Dict[str, Any]] = None
+    message: Optional[str] = None

app/schemas/voice.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, Field
+
+
+class VoiceGenerationRequest(BaseModel):
+    text: str = Field(..., min_length=1, max_length=5000, description="要转换为语音的文本内容")
+    voice_name: str = Field(
+        default="zh-CN-XiaoxiaoNeural", 
+        description="语音名称，如：zh-CN-XiaoxiaoNeural, zh-CN-YunxiNeural"
+    )
+    voice_rate: float = Field(
+        default=0, 
+        ge=-1, 
+        le=1, 
+        description="语速调整，范围 -1.0 到 1.0，0 表示正常速度"
+    )
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "text": "你好，这是一个测试文本，用于生成语音和字幕文件。",
+                    "voice_name": "zh-CN-XiaoxiaoNeural",
+                    "voice_rate": 0
+                }
+            ]
+        }
+    }
+
+
+class VoiceGenerationResponse(BaseModel):
+    audio_url: str = Field(..., description="生成的音频文件URL")
+    subtitle_url: str = Field(..., description="生成的字幕文件URL")
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "audio_url": "/tasks/audio_1234567890_abcd1234.mp3",
+                    "subtitle_url": "/tasks/subtitle_1234567890_abcd1234.srt"
+                }
+            ]
+        }
+    }

app/services/__init__.py

@@ -0,0 +1 @@
+

app/services/health.py

@@ -0,0 +1,19 @@
+from app.config import get_settings
+
+settings = get_settings()
+
+
+class HealthService:
+    async def check_health(self) -> dict:
+        """
+        检查各个服务的健康状态
+        """
+        
+        return {
+            "status": "healthy",
+            "version": settings.VERSION,
+        }
+
+
+# 创建服务实例
+health_service = HealthService()

app/services/llm.py

@@ -0,0 +1,332 @@
+from openai import OpenAI
+from app.config import get_settings
+from loguru import logger
+from typing import List, Dict, Any
+import json
+from http import HTTPStatus
+from pathlib import PurePosixPath
+import requests
+from urllib.parse import urlparse, unquote
+import random
+
+from app.models.const import LANGUAGE_NAMES, Language
+from app.exceptions import LLMResponseValidationError
+import dashscope
+
+from dashscope import ImageSynthesis
+from app.schemas.llm import (
+    StoryGenerationRequest,
+)
+settings = get_settings()
+
+
+openai_client = None
+if settings.openai_api_key:
+   openai_client = OpenAI(api_key=settings.openai_api_key, base_url=settings.openai_base_url or "https://api.openai.com/v1")
+aliyun_text_client = None
+if settings.aliyun_api_key:
+    dashscope.api_key = settings.aliyun_api_key
+    aliyun_text_client = OpenAI(base_url=settings.aliyun_base_url or "https://dashscope.aliyuncs.com/compatible-mode/v1", api_key=settings.aliyun_api_key) 
+if settings.deepseek_api_key:
+    deepseek_client = OpenAI(api_key=settings.deepseek_api_key, base_url=settings.deepseek_base_url or "https://api.deepseek.com/v1")
+if settings.ollama_api_key:
+    ollama_client = OpenAI(api_key=settings.ollama_api_key, base_url=settings.ollama_base_url or "http://localhost:11434/v1")
+if settings.siliconflow_api_key:
+    siliconflow_client = OpenAI(api_key=settings.siliconflow_api_key, base_url=settings.siliconflow_base_url or "https://api.siliconflow.cn/v1")
+
+class LLMService:
+    def __init__(self):
+        self.openai_client = openai_client
+        self.aliyun_text_client = aliyun_text_client
+        self.text_llm_model = settings.text_llm_model
+        self.image_llm_model = settings.image_llm_model
+    
+    async def generate_story(self, request: StoryGenerationRequest) -> List[Dict[str, Any]]:
+        """生成故事场景
+        Args:
+            story_prompt (str, optional): 故事提示. Defaults to None.
+            segments (int, optional): 故事分段数. Defaults to 3.
+
+        Returns:
+            List[Dict[str, Any]]: 故事场景列表
+        """
+        
+        messages = [
+            {"role": "system", "content": "你是一个专业的故事创作者，善于创作引人入胜的故事。请只返回JSON格式的内容。"},
+            {"role": "user", "content": await self._get_story_prompt(request.story_prompt, request.language, request.segments)}
+        ]
+        logger.info(f"prompt messages: {json.dumps(messages, indent=4, ensure_ascii=False)}")
+        response = await self._generate_response(text_llm_provider = request.text_llm_provider or None, text_llm_model = request.text_llm_model or None, messages=messages, response_format="json_object")
+        response = response["list"]
+        response = self.normalize_keys(response)
+
+        logger.info(f"Generated story: {json.dumps(response, indent=4, ensure_ascii=False)}")
+        # 验证响应格式
+        self._validate_story_response(response)
+        
+        return response
+    def normalize_keys(self, data):
+        """
+        阿里云和 openai 的模型返回结果不一致，处理一下
+        修改对象中非 `text` 的键为 `image_prompt`
+        - 如果是字典，替换 `text` 以外的单个键为 `image_prompt`
+        - 如果是列表，对列表中的每个对象递归处理
+        """
+        if isinstance(data, dict):
+            # 如果是字典，处理键值
+            if "text" in data:
+                # 找到非 `text` 的键
+                other_keys = [key for key in data.keys() if key != "text"]
+                # 确保只处理一个非 `text` 键的情况
+                if len(other_keys) == 1:
+                    data["image_prompt"] = data.pop(other_keys[0])
+                elif len(other_keys) > 1:
+                    raise ValueError(f"Unexpected extra keys: {other_keys}. Only one non-'text' key is allowed.")
+            return data
+        elif isinstance(data, list):
+            # 如果是列表，递归处理每个对象
+            return [self.normalize_keys(item) for item in data]
+        else:
+            raise TypeError("Input must be a dict or list of dicts")
+
+    def generate_image(self, *, prompt: str, image_llm_provider: str = None, image_llm_model: str = None, resolution: str = "1024x1024") -> str:
+        # return "https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/1d/56/20250118/3c4cc727/4fc622b5-54a6-484c-bf1f-f1cfb66ace2d-1.png?Expires=1737290655&OSSAccessKeyId=LTAI5tQZd8AEcZX6KZV4G8qL&Signature=W8D4CN3uonQ2pL1e9xGMWufz33E%3D"
+        """生成图片
+
+        Args:
+            prompt (str): 图片描述
+            resolution (str): 图片分辨率，默认为 1024x1024
+
+        Returns:
+            str: 图片URL
+        """
+
+        
+        image_llm_provider =  image_llm_provider or settings.image_provider
+        image_llm_model = image_llm_model or settings.image_llm_model
+
+        try:
+            # 添加安全提示词
+            safe_prompt = f"Create a safe, family-friendly illustration. {prompt} The image should be appropriate for all ages, non-violent, and non-controversial."
+            
+            if image_llm_provider == "aliyun":
+                rsp = ImageSynthesis.call(model=image_llm_model,
+                              prompt=prompt,
+                              size=resolution,)
+                if rsp.status_code == HTTPStatus.OK:
+                    # print("aliyun image response", rsp.output)
+                    for result in rsp.output.results:
+                        return result.url
+                else:
+                    error_message = f'Failed, status_code: {rsp.status_code}, code: {rsp.code}, message: {rsp.message}'
+                    logger.error(error_message)
+                    raise Exception(error_message)
+            elif image_llm_provider == "openai":
+                if (resolution != None):
+                    resolution = resolution.replace("*", "x")
+                response = self.openai_client.images.generate(
+                    model=image_llm_model,
+                    prompt=safe_prompt,
+                    size=resolution,
+                    quality="standard",
+                    n=1
+                )
+                logger.info("image generate res", response.data[0].url)
+                return response.data[0].url
+            elif image_llm_provider == "siliconflow":
+                if (resolution != None):
+                    resolution = resolution.replace("*", "x")
+                payload = {
+                    "model": image_llm_model,
+                    "prompt": safe_prompt,
+                    "seed": random.randint(1000000, 4999999999),
+                    "image_size": resolution,
+                    "guidance_scale": 7.5,
+                    "batch_size": 1,
+                }
+                headers = {
+                    "Authorization": "Bearer " + settings.siliconflow_api_key,
+                    "Content-Type": "application/json"
+                }
+                response = requests.request("POST", "https://api.siliconflow.cn/v1/images/generations", json=payload, headers=headers)
+                if response.text != None:
+                    response = json.loads(response.text)
+                    return response["images"][0]["url"]
+                else:
+                    raise Exception(response.text)
+        except Exception as e:
+            logger.error(f"Failed to generate image: {e}")
+            return ""
+
+    async def generate_story_with_images(self, request: StoryGenerationRequest) -> List[Dict[str, Any]]:
+        """生成故事和配图
+        Args:
+            story_prompt (str, optional): 故事提示. Defaults to None.
+            language (Language, optional): 语言. Defaults to Language.CHINESE.
+            segments (int, optional): 故事分段数. Defaults to 3.
+
+        Returns:
+            List[Dict[str, Any]]: 故事场景列表，每个场景包含文本、图片提示词和图片URL
+        """
+        # 先生成故事
+        story_segments = await self.generate_story(
+            request,
+        )
+
+        # 为每个场景生成图片
+        for segment in story_segments:
+            try:
+                image_url = self.generate_image(prompt=segment["image_prompt"], resolution=request.resolution, image_llm_provider=request.image_llm_provider, image_llm_model=request.image_llm_model)
+                segment["url"] = image_url
+            except Exception as e:
+                logger.error(f"Failed to generate image for segment: {e}")
+                segment["url"] = None
+
+        return story_segments
+    
+    def get_llm_providers(self) -> Dict[str, List[str]]:
+        imgLLMList = []
+        textLLMList = []
+        if settings.openai_api_key:
+            textLLMList.append("openai")
+            imgLLMList.append("openai")
+        if settings.aliyun_api_key:
+            textLLMList.append("aliyun")
+            imgLLMList.append("aliyun")
+        if settings.deepseek_api_key:
+            textLLMList.append("deepseek")
+        if settings.ollama_api_key:
+            textLLMList.append("ollama")
+        if settings.siliconflow_api_key:
+            textLLMList.append("siliconflow")
+            imgLLMList.append("siliconflow")
+        return { "textLLMProviders": textLLMList, "imageLLMProviders": imgLLMList }
+
+    def _validate_story_response(self, response: any) -> None:
+        """验证故事生成响应
+
+        Args:
+            response: LLM 响应
+
+        Raises:
+            LLMResponseValidationError: 响应格式错误
+        """
+        if not isinstance(response, list):
+            raise LLMResponseValidationError("Response must be an array")
+
+        for i, scene in enumerate(response):
+            if not isinstance(scene, dict):
+                raise LLMResponseValidationError(f"story item {i} must be an object")
+            
+            if "text" not in scene:
+                raise LLMResponseValidationError(f"Scene {i} missing 'text' field")
+            
+            if "image_prompt" not in scene:
+                raise LLMResponseValidationError(f"Scene {i} missing 'image_prompt' field")
+            
+            if not isinstance(scene["text"], str):
+                raise LLMResponseValidationError(f"Scene {i} 'text' must be a string")
+            
+            if not isinstance(scene["image_prompt"], str):
+                raise LLMResponseValidationError(f"Scene {i} 'image_prompt' must be a string")
+
+    async def _generate_response(self, *, text_llm_provider: str = None, text_llm_model: str = None, messages: List[Dict[str, str]], response_format: str = "json_object") -> any:
+        """生成 LLM 响应
+
+        Args:
+            messages: 消息列表
+            response_format: 响应格式，默认为 json_object
+
+        Returns:
+            Dict[str, Any]: 解析后的响应
+
+        Raises:
+            Exception: 请求失败或解析失败时抛出异常
+        """
+        if text_llm_provider == None:
+            text_llm_provider = settings.text_llm_provider
+        if text_llm_provider == "aliyun":
+            text_client = self.aliyun_text_client
+        elif text_llm_provider == "openai":
+            text_client = self.openai_client
+        elif text_llm_provider == "deepseek":
+            text_client = deepseek_client
+        elif text_llm_provider == "ollama":
+            text_client = ollama_client
+        elif text_llm_provider == "siliconflow":
+            text_client = siliconflow_client
+        if text_llm_model == None:
+            text_llm_model = settings.text_llm_model
+        response = text_client.chat.completions.create(
+            model= text_llm_model,
+            response_format={"type": response_format},
+            messages=messages,
+        )
+        try:
+            content = response.choices[0].message.content
+            result = json.loads(content)
+            return result
+        except Exception as e:
+            logger.error(f"Failed to parse response: {e}")
+            raise e
+
+    async def _get_story_prompt(self, story_prompt: str = None, language: Language = Language.CHINESE_CN, segments: int = 3) -> str:
+        """生成故事提示词
+
+        Args:
+            story_prompt (str, optional): 故事提示. Defaults to None.
+            segments (int, optional): 故事分段数. Defaults to 3.
+
+        Returns:
+            str: 完整的提示词
+        """
+
+        languageValue = LANGUAGE_NAMES[language]
+        if story_prompt:
+            base_prompt = f"讲一个故事，主题是：{story_prompt}"
+        
+        return f"""
+        {base_prompt}. The story needs to be divided into {segments} scenes, and each scene must include descriptive text and an image prompt.
+
+        Please return the result in the following JSON format, where the key `list` contains an array of objects:
+
+        **Expected JSON format**:
+        {{
+            "list": [
+                {{
+                    "text": "Descriptive text for the scene",
+                    "image_prompt": "Detailed image generation prompt, described in English"
+                }},
+                {{
+                    "text": "Another scene description text",
+                    "image_prompt": "Another detailed image generation prompt in English"
+                }}
+            ]
+        }}
+
+        **Requirements**:
+        1. The root object must contain a key named `list`, and its value must be an array of scene objects.
+        2. Each object in the `list` array must include:
+            - `text`: A descriptive text for the scene, written in {languageValue}.
+            - `image_prompt`: A detailed prompt for generating an image, written in English.
+        3. Ensure the JSON format matches the above example exactly. Avoid extra fields or incorrect key names like `cimage_prompt` or `inage_prompt`.
+
+        **Important**:
+        - If there is only one scene, the array under `list` should contain a single object.
+        - The output must be a valid JSON object. Do not include explanations, comments, or additional content outside the JSON.
+
+        Example output:
+        {{
+            "list": [
+                {{
+                    "text": "Scene description text",
+                    "image_prompt": "Detailed image generation prompt in English"
+                }}
+            ]
+        }}
+        """
+
+    
+
+# 创建服务实例
+llm_service = LLMService()

app/services/story.py

@@ -0,0 +1,49 @@
+from typing import List, Optional
+from app.schemas.story import Story, StoryCreate, StoryUpdate
+import uuid
+
+
+class StoryService:
+    def __init__(self):
+        # 使用内存存储示例数据
+        self._stories = {}
+
+    def get_stories(self, skip: int = 0, limit: int = 10) -> List[Story]:
+        stories = list(self._stories.values())
+        return stories[skip : skip + limit]
+
+    def get_story(self, story_id: str) -> Optional[Story]:
+        return self._stories.get(story_id)
+
+    def create_story(self, story: StoryCreate) -> Story:
+        story_id = str(uuid.uuid4())
+        story_data = Story(
+            id=story_id,
+            title=story.title,
+            description=story.description,
+        )
+        self._stories[story_id] = story_data
+        return story_data
+
+    def update_story(self, story_id: str, story: StoryUpdate) -> Optional[Story]:
+        if story_id not in self._stories:
+            return None
+        
+        stored_story = self._stories[story_id]
+        update_data = story.model_dump(exclude_unset=True)
+        
+        for field, value in update_data.items():
+            setattr(stored_story, field, value)
+            
+        self._stories[story_id] = stored_story
+        return stored_story
+
+    def delete_story(self, story_id: str) -> bool:
+        if story_id not in self._stories:
+            return False
+        del self._stories[story_id]
+        return True
+
+
+# 创建一个全局的服务实例
+story_service = StoryService()

app/services/video.py

@@ -0,0 +1,277 @@
+import os
+import time
+import json
+from typing import List
+from app.schemas.llm import StoryGenerationRequest
+from loguru import logger
+from app.models.const import StoryType, ImageStyle
+from app.schemas.video import VideoGenerateRequest, StoryScene
+from app.services.llm import llm_service
+from app.services.voice import generate_voice
+from app.utils import utils
+from moviepy import (
+    VideoFileClip,
+    ImageClip,
+    AudioFileClip,
+    TextClip,
+    CompositeVideoClip,
+    concatenate_videoclips,
+    afx,
+)
+from moviepy.video.tools import subtitles
+from moviepy.video.tools.subtitles import SubtitlesClip
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+import requests
+import random
+
+def wrap_text(text, max_width, font="Arial", fontsize=60):
+    # Create ImageFont
+    font = ImageFont.truetype(font, fontsize)
+
+    def get_text_size(inner_text):
+        inner_text = inner_text.strip()
+        left, top, right, bottom = font.getbbox(inner_text)
+        return right - left, bottom - top
+
+    width, height = get_text_size(text)
+    if width <= max_width:
+        return text, height
+
+    # logger.warning(f"wrapping text, max_width: {max_width}, text_width: {width}, text: {text}")
+
+    processed = True
+
+    _wrapped_lines_ = []
+    words = text.split(" ")
+    _txt_ = ""
+    for word in words:
+        _before = _txt_
+        _txt_ += f"{word} "
+        _width, _height = get_text_size(_txt_)
+        if _width <= max_width:
+            continue
+        else:
+            if _txt_.strip() == word.strip():
+                processed = False
+                break
+            _wrapped_lines_.append(_before)
+            _txt_ = f"{word} "
+    _wrapped_lines_.append(_txt_)
+    if processed:
+        _wrapped_lines_ = [line.strip() for line in _wrapped_lines_]
+        result = "\n".join(_wrapped_lines_).strip()
+        height = len(_wrapped_lines_) * height
+        # logger.warning(f"wrapped text: {result}")
+        return result, height
+
+    _wrapped_lines_ = []
+    chars = list(text)
+    _txt_ = ""
+    for word in chars:
+        _txt_ += word
+        _width, _height = get_text_size(_txt_)
+        if _width <= max_width:
+            continue
+        else:
+            _wrapped_lines_.append(_txt_)
+            _txt_ = ""
+    _wrapped_lines_.append(_txt_)
+    result = "\n".join(_wrapped_lines_).strip()
+    height = len(_wrapped_lines_) * height
+    # logger.warning(f"wrapped text: {result}")
+    return result, height
+
+async def create_video_with_scenes(task_dir: str, scenes: List[StoryScene], voice_name: str, voice_rate: float, test_mode: bool = False) -> str:
+    """创建带有场景的视频
+
+    Args:
+        task_dir (str): 任务目录
+        scenes (List[StoryScene]): 场景列表
+        voice_name (str): 语音名称
+        voice_rate (float): 语音速率
+        test_mode (bool): 是否为测试模式，如果是则使用已有的图片、音频、字幕文件
+    """
+    clips = []
+    for i, scene in enumerate(scenes, 1):
+        try:
+            # 获取文件路径
+            image_file = os.path.join(task_dir, f"{i}.png")
+            audio_file = os.path.join(task_dir, f"{i}.mp3")
+            subtitle_file = os.path.join(task_dir, f"{i}.srt")
+
+            # 测试模式下检查文件是否存在
+            if test_mode:
+                if not (os.path.exists(image_file) and os.path.exists(audio_file) and os.path.exists(subtitle_file)):
+                    logger.warning(f"Test mode: Required files not found for scene {i}")
+                    raise FileNotFoundError("Required files not found")
+            else:
+                # 正式模式下生成所需文件
+                logger.info(f"Processing scene {i}")
+                audio_file, subtitle_file = await generate_voice(
+                    scene.text,
+                    voice_name,
+                    voice_rate,
+                    audio_file,
+                    subtitle_file
+                )
+            
+            # 获取字幕的总时长
+            subs = subtitles.file_to_subtitles(subtitle_file, encoding="utf-8")
+            subtitle_duration = max([tb for ((ta, tb), txt) in subs])
+                    
+            # 创建图片剪辑
+            image_clip = ImageClip(image_file)
+            origin_image_w, origin_image_h = image_clip.size  # 获取放大后的图片尺寸
+            image_scale = 1.2
+            image_clip = image_clip.resized((origin_image_w*image_scale,origin_image_h*image_scale))
+            image_w, image_h = image_clip.size  # 获取放大后的图片尺寸
+            # 确保图片视频时长至少和字幕一样长
+            image_clip = image_clip.with_duration(subtitle_duration)
+
+            width_diff = origin_image_w * (image_scale-1)
+            def debug_position(t):
+                # print(f"当前时间 t = {t}", subtitle_duration, width_diff, width_diff/subtitle_duration*t)  # 输出当前时间
+                return (-width_diff/subtitle_duration*t, 'center')
+            image_clip = image_clip.with_position(debug_position)
+            # 创建音频剪辑
+            audio_clip = AudioFileClip(audio_file)
+            image_clip = image_clip.with_audio(audio_clip)
+            # 使用系统字体
+            font_path = os.path.join(utils.resource_dir(), "fonts", "STHeitiLight.ttc")
+            if not os.path.exists(font_path):
+                logger.warning("Font file not found, using default font")
+                raise FileNotFoundError("Font file not found: " + font_path)
+            else:
+                logger.info(f"Using font: {font_path}")
+            
+            print(f"Using font: {font_path}")
+            # 添加字幕
+            if os.path.exists(subtitle_file):
+                logger.info(f"Loading subtitle file: {subtitle_file}")
+                try:
+                    def make_textclip(text):
+                        return TextClip(
+                            text=text,
+                            font=font_path,
+                            font_size=60,
+                        )
+                    def create_text_clip(subtitle_item):
+                        phrase = subtitle_item[1]
+                        max_width = (origin_image_w * 0.9)
+                        wrapped_txt, txt_height = wrap_text(
+                            phrase, max_width=max_width, font=font_path, fontsize=60
+                        )
+                        _clip = TextClip(
+                            text=wrapped_txt,
+                            font=font_path,
+                            font_size=60,
+                            color="white",
+                            stroke_color="black",
+                            stroke_width=2,
+                        )
+                        duration = subtitle_item[0][1] - subtitle_item[0][0]
+                        _clip = _clip.with_start(subtitle_item[0][0])
+                        _clip = _clip.with_end(subtitle_item[0][1])
+                        _clip = _clip.with_duration(duration)
+                        _clip = _clip.with_position(("center", origin_image_h * 0.95 - _clip.h - 50))
+                        return _clip
+                    
+                    sub = SubtitlesClip(subtitle_file, encoding="utf-8", make_textclip=make_textclip)
+
+                    text_clips = []
+                    for item in sub.subtitles:
+                        clip = create_text_clip(subtitle_item=item)
+                        text_clips.append(clip)
+                    video_clip = CompositeVideoClip([image_clip, *text_clips], (origin_image_w, origin_image_h))
+                    clips.append(video_clip)
+                    logger.info(f"Added subtitles for scene {i}")
+                except Exception as e:
+                    logger.error(f"Failed to add subtitles for scene {i}: {str(e)}")
+                    clips.append(image_clip)
+            else:
+                logger.warning(f"Subtitle file not found: {subtitle_file}")
+                clips.append(image_clip)
+        except Exception as e:
+            logger.error(f"Failed to process scene {i}: {str(e)}")
+            raise e
+    
+    if not clips:
+        raise ValueError("No valid clips to combine")
+
+    # 合并所有片段
+    logger.info("Merging all clips")
+    final_clip = concatenate_videoclips(clips)
+    video_file = os.path.join(task_dir, "video.mp4")
+    logger.info(f"Writing video to {video_file}")
+    final_clip.write_videofile(video_file, fps=24, codec='libx264', audio_codec='aac')
+    
+    return video_file
+
+
+async def generate_video(request: VideoGenerateRequest):
+    """生成视频
+
+    Args:
+        request (VideoGenerateRequest): 视频生成请求
+    """
+    try:
+        # 测试模式下，从 story.json 中读取请求参数
+        if request.test_mode:
+            task_id = request.task_id or str(int(time.time()))
+            task_dir = utils.task_dir(task_id)
+            if not os.path.exists(task_dir):
+                raise ValueError(f"Task directory not found: {task_dir}")
+            # 从 story.json 中读取数据
+            story_file = os.path.join(task_dir, "story.json")
+            if not os.path.exists(story_file):
+                raise ValueError(f"Story file not found: {story_file}")
+            
+            with open(story_file, "r", encoding="utf-8") as f:
+                story_data = json.load(f)
+                print("story_data", story_data)
+            
+            request = VideoGenerateRequest(**story_data)
+            request.test_mode = True
+            scenes = [StoryScene(**scene) for scene in story_data.get("scenes", [])]
+        else:
+            req = StoryGenerationRequest(
+                resolution=request.resolution,
+                story_prompt=request.story_prompt,
+                language=request.language,
+                segments=request.segments,
+                text_llm_provider=request.text_llm_provider,
+                text_llm_model=request.text_llm_model,
+                image_llm_provider=request.image_llm_provider,
+                image_llm_model=request.image_llm_model
+            )
+            story_list = await llm_service.generate_story_with_images(request=req)
+            scenes = [StoryScene(text=scene["text"], image_prompt=scene["image_prompt"], url=scene["url"]) for scene in story_list]
+            
+            # 保存 story.json
+            story_data = request.model_dump()
+            story_data["scenes"] = [scene.model_dump() for scene in scenes]
+            task_id = str(int(time.time()))
+            task_dir = utils.task_dir(task_id)
+            os.makedirs(task_dir, exist_ok=True)
+            story_file = os.path.join(task_dir, "story.json")
+            for i, scene in enumerate(story_list, 1):
+                if scene.get("url"):
+                    image_path = os.path.join(task_dir, f"{i}.png")
+                    try:
+                        response = requests.get(scene["url"])
+                        if response.status_code == 200:
+                            with open(image_path, "wb") as f:
+                                f.write(response.content)
+                            logger.info(f"Downloaded image {i} to {image_path}")
+                    except Exception as e:
+                        logger.error(f"Failed to download image {i}: {e}")
+
+            with open(story_file, "w", encoding="utf-8") as f:
+                json.dump(story_data, f, ensure_ascii=False, indent=2)
+        # return ""
+        # 生成视频
+        return await create_video_with_scenes(task_dir, scenes, request.voice_name, request.voice_rate, request.test_mode)
+    except Exception as e:
+        logger.error(f"Failed to generate video: {e}")
+        raise e

app/services/voice.py

@@ -0,0 +1,1275 @@
+import os
+import asyncio
+import time
+import uuid
+import json
+import edge_tts
+import re
+import xml.sax.saxutils
+from edge_tts import SubMaker, submaker
+from edge_tts.submaker import mktimestamp
+from moviepy.video.tools import subtitles
+from loguru import logger
+from typing import Tuple
+from xml.sax.saxutils import unescape
+
+PUNCTUATIONS = [
+    "?",
+    ",",
+    ".",
+    "、",
+    ";",
+    ":",
+    "!",
+    "…",
+    "？",
+    "，",
+    "。",
+    "、",
+    "；",
+    "：",
+    "！",
+    "...",
+]
+
+def split_string_by_punctuations(s):
+    result = []
+    txt = ""
+
+    previous_char = ""
+    next_char = ""
+    for i in range(len(s)):
+        char = s[i]
+        if char == "\n":
+            if txt.strip():  # 只有在非空的情况下才添加
+                result.append(txt.strip())
+            txt = ""
+            continue
+
+        if i > 0:
+            previous_char = s[i - 1]
+        if i < len(s) - 1:
+            next_char = s[i + 1]
+
+        if char == "." and previous_char.isdigit() and next_char.isdigit():
+            txt += char
+            continue
+
+        if char not in PUNCTUATIONS:
+            txt += char
+        else:
+            if txt.strip():  # 只有在非空的情况下才添加
+                result.append(txt.strip())
+            txt = ""
+    if txt.strip():  # 最后一段如果非空也要添加
+        result.append(txt.strip())
+    
+    # 过滤掉空字符串和只包含标点符号的片段
+    def is_valid_segment(segment):
+        # 去掉所有标点符号后还有内容的才是有效片段
+        return bool(re.sub(r'[^\w\s]', '', segment).strip())
+    
+    result = list(filter(is_valid_segment, result))
+    return result
+
+def get_all_azure_voices(filter_locals=None) -> list[str]:
+    if filter_locals is None:
+        filter_locals = ["zh-CN", "en-US", "zh-TW", "ja-JP", "ko-KR"]
+    voices_str = """
+Name: af-ZA-AdriNeural
+Gender: Female
+
+Name: af-ZA-WillemNeural
+Gender: Male
+
+Name: am-ET-AmehaNeural
+Gender: Male
+
+Name: am-ET-MekdesNeural
+Gender: Female
+
+Name: ar-AE-FatimaNeural
+Gender: Female
+
+Name: ar-AE-HamdanNeural
+Gender: Male
+
+Name: ar-BH-AliNeural
+Gender: Male
+
+Name: ar-BH-LailaNeural
+Gender: Female
+
+Name: ar-DZ-AminaNeural
+Gender: Female
+
+Name: ar-DZ-IsmaelNeural
+Gender: Male
+
+Name: ar-EG-SalmaNeural
+Gender: Female
+
+Name: ar-EG-ShakirNeural
+Gender: Male
+
+Name: ar-IQ-BasselNeural
+Gender: Male
+
+Name: ar-IQ-RanaNeural
+Gender: Female
+
+Name: ar-JO-SanaNeural
+Gender: Female
+
+Name: ar-JO-TaimNeural
+Gender: Male
+
+Name: ar-KW-FahedNeural
+Gender: Male
+
+Name: ar-KW-NouraNeural
+Gender: Female
+
+Name: ar-LB-LaylaNeural
+Gender: Female
+
+Name: ar-LB-RamiNeural
+Gender: Male
+
+Name: ar-LY-ImanNeural
+Gender: Female
+
+Name: ar-LY-OmarNeural
+Gender: Male
+
+Name: ar-MA-JamalNeural
+Gender: Male
+
+Name: ar-MA-MounaNeural
+Gender: Female
+
+Name: ar-OM-AbdullahNeural
+Gender: Male
+
+Name: ar-OM-AyshaNeural
+Gender: Female
+
+Name: ar-QA-AmalNeural
+Gender: Female
+
+Name: ar-QA-MoazNeural
+Gender: Male
+
+Name: ar-SA-HamedNeural
+Gender: Male
+
+Name: ar-SA-ZariyahNeural
+Gender: Female
+
+Name: ar-SY-AmanyNeural
+Gender: Female
+
+Name: ar-SY-LaithNeural
+Gender: Male
+
+Name: ar-TN-HediNeural
+Gender: Male
+
+Name: ar-TN-ReemNeural
+Gender: Female
+
+Name: ar-YE-MaryamNeural
+Gender: Female
+
+Name: ar-YE-SalehNeural
+Gender: Male
+
+Name: az-AZ-BabekNeural
+Gender: Male
+
+Name: az-AZ-BanuNeural
+Gender: Female
+
+Name: bg-BG-BorislavNeural
+Gender: Male
+
+Name: bg-BG-KalinaNeural
+Gender: Female
+
+Name: bn-BD-NabanitaNeural
+Gender: Female
+
+Name: bn-BD-PradeepNeural
+Gender: Male
+
+Name: bn-IN-BashkarNeural
+Gender: Male
+
+Name: bn-IN-TanishaaNeural
+Gender: Female
+
+Name: bs-BA-GoranNeural
+Gender: Male
+
+Name: bs-BA-VesnaNeural
+Gender: Female
+
+Name: ca-ES-EnricNeural
+Gender: Male
+
+Name: ca-ES-JoanaNeural
+Gender: Female
+
+Name: cs-CZ-AntoninNeural
+Gender: Male
+
+Name: cs-CZ-VlastaNeural
+Gender: Female
+
+Name: cy-GB-AledNeural
+Gender: Male
+
+Name: cy-GB-NiaNeural
+Gender: Female
+
+Name: da-DK-ChristelNeural
+Gender: Female
+
+Name: da-DK-JeppeNeural
+Gender: Male
+
+Name: de-AT-IngridNeural
+Gender: Female
+
+Name: de-AT-JonasNeural
+Gender: Male
+
+Name: de-CH-JanNeural
+Gender: Male
+
+Name: de-CH-LeniNeural
+Gender: Female
+
+Name: de-DE-AmalaNeural
+Gender: Female
+
+Name: de-DE-ConradNeural
+Gender: Male
+
+Name: de-DE-FlorianMultilingualNeural
+Gender: Male
+
+Name: de-DE-KatjaNeural
+Gender: Female
+
+Name: de-DE-KillianNeural
+Gender: Male
+
+Name: de-DE-SeraphinaMultilingualNeural
+Gender: Female
+
+Name: el-GR-AthinaNeural
+Gender: Female
+
+Name: el-GR-NestorasNeural
+Gender: Male
+
+Name: en-AU-NatashaNeural
+Gender: Female
+
+Name: en-AU-WilliamNeural
+Gender: Male
+
+Name: en-CA-ClaraNeural
+Gender: Female
+
+Name: en-CA-LiamNeural
+Gender: Male
+
+Name: en-GB-LibbyNeural
+Gender: Female
+
+Name: en-GB-MaisieNeural
+Gender: Female
+
+Name: en-GB-RyanNeural
+Gender: Male
+
+Name: en-GB-SoniaNeural
+Gender: Female
+
+Name: en-GB-ThomasNeural
+Gender: Male
+
+Name: en-HK-SamNeural
+Gender: Male
+
+Name: en-HK-YanNeural
+Gender: Female
+
+Name: en-IE-ConnorNeural
+Gender: Male
+
+Name: en-IE-EmilyNeural
+Gender: Female
+
+Name: en-IN-NeerjaExpressiveNeural
+Gender: Female
+
+Name: en-IN-NeerjaNeural
+Gender: Female
+
+Name: en-IN-PrabhatNeural
+Gender: Male
+
+Name: en-KE-AsiliaNeural
+Gender: Female
+
+Name: en-KE-ChilembaNeural
+Gender: Male
+
+Name: en-NG-AbeoNeural
+Gender: Male
+
+Name: en-NG-EzinneNeural
+Gender: Female
+
+Name: en-NZ-MitchellNeural
+Gender: Male
+
+Name: en-NZ-MollyNeural
+Gender: Female
+
+Name: en-PH-JamesNeural
+Gender: Male
+
+Name: en-PH-RosaNeural
+Gender: Female
+
+Name: en-SG-LunaNeural
+Gender: Female
+
+Name: en-SG-WayneNeural
+Gender: Male
+
+Name: en-TZ-ElimuNeural
+Gender: Male
+
+Name: en-TZ-ImaniNeural
+Gender: Female
+
+Name: en-US-AnaNeural
+Gender: Female
+
+Name: en-US-AndrewMultilingualNeural
+Gender: Male
+
+Name: en-US-AndrewNeural
+Gender: Male
+
+Name: en-US-AriaNeural
+Gender: Female
+
+Name: en-US-AvaMultilingualNeural
+Gender: Female
+
+Name: en-US-AvaNeural
+Gender: Female
+
+Name: en-US-BrianMultilingualNeural
+Gender: Male
+
+Name: en-US-BrianNeural
+Gender: Male
+
+Name: en-US-ChristopherNeural
+Gender: Male
+
+Name: en-US-EmmaMultilingualNeural
+Gender: Female
+
+Name: en-US-EmmaNeural
+Gender: Female
+
+Name: en-US-EricNeural
+Gender: Male
+
+Name: en-US-GuyNeural
+Gender: Male
+
+Name: en-US-JennyNeural
+Gender: Female
+
+Name: en-US-MichelleNeural
+Gender: Female
+
+Name: en-US-RogerNeural
+Gender: Male
+
+Name: en-US-SteffanNeural
+Gender: Male
+
+Name: en-ZA-LeahNeural
+Gender: Female
+
+Name: en-ZA-LukeNeural
+Gender: Male
+
+Name: es-AR-ElenaNeural
+Gender: Female
+
+Name: es-AR-TomasNeural
+Gender: Male
+
+Name: es-BO-MarceloNeural
+Gender: Male
+
+Name: es-BO-SofiaNeural
+Gender: Female
+
+Name: es-CL-CatalinaNeural
+Gender: Female
+
+Name: es-CL-LorenzoNeural
+Gender: Male
+
+Name: es-CO-GonzaloNeural
+Gender: Male
+
+Name: es-CO-SalomeNeural
+Gender: Female
+
+Name: es-CR-JuanNeural
+Gender: Male
+
+Name: es-CR-MariaNeural
+Gender: Female
+
+Name: es-CU-BelkysNeural
+Gender: Female
+
+Name: es-CU-ManuelNeural
+Gender: Male
+
+Name: es-DO-EmilioNeural
+Gender: Male
+
+Name: es-DO-RamonaNeural
+Gender: Female
+
+Name: es-EC-AndreaNeural
+Gender: Female
+
+Name: es-EC-LuisNeural
+Gender: Male
+
+Name: es-ES-AlvaroNeural
+Gender: Male
+
+Name: es-ES-ElviraNeural
+Gender: Female
+
+Name: es-ES-XimenaNeural
+Gender: Female
+
+Name: es-GQ-JavierNeural
+Gender: Male
+
+Name: es-GQ-TeresaNeural
+Gender: Female
+
+Name: es-GT-AndresNeural
+Gender: Male
+
+Name: es-GT-MartaNeural
+Gender: Female
+
+Name: es-HN-CarlosNeural
+Gender: Male
+
+Name: es-HN-KarlaNeural
+Gender: Female
+
+Name: es-MX-DaliaNeural
+Gender: Female
+
+Name: es-MX-JorgeNeural
+Gender: Male
+
+Name: es-NI-FedericoNeural
+Gender: Male
+
+Name: es-NI-YolandaNeural
+Gender: Female
+
+Name: es-PA-MargaritaNeural
+Gender: Female
+
+Name: es-PA-RobertoNeural
+Gender: Male
+
+Name: es-PE-AlexNeural
+Gender: Male
+
+Name: es-PE-CamilaNeural
+Gender: Female
+
+Name: es-PR-KarinaNeural
+Gender: Female
+
+Name: es-PR-VictorNeural
+Gender: Male
+
+Name: es-PY-MarioNeural
+Gender: Male
+
+Name: es-PY-TaniaNeural
+Gender: Female
+
+Name: es-SV-LorenaNeural
+Gender: Female
+
+Name: es-SV-RodrigoNeural
+Gender: Male
+
+Name: es-US-AlonsoNeural
+Gender: Male
+
+Name: es-US-PalomaNeural
+Gender: Female
+
+Name: es-UY-MateoNeural
+Gender: Male
+
+Name: es-UY-ValentinaNeural
+Gender: Female
+
+Name: es-VE-PaolaNeural
+Gender: Female
+
+Name: es-VE-SebastianNeural
+Gender: Male
+
+Name: et-EE-AnuNeural
+Gender: Female
+
+Name: et-EE-KertNeural
+Gender: Male
+
+Name: fa-IR-DilaraNeural
+Gender: Female
+
+Name: fa-IR-FaridNeural
+Gender: Male
+
+Name: fi-FI-HarriNeural
+Gender: Male
+
+Name: fi-FI-NooraNeural
+Gender: Female
+
+Name: fil-PH-AngeloNeural
+Gender: Male
+
+Name: fil-PH-BlessicaNeural
+Gender: Female
+
+Name: fr-BE-CharlineNeural
+Gender: Female
+
+Name: fr-BE-GerardNeural
+Gender: Male
+
+Name: fr-CA-AntoineNeural
+Gender: Male
+
+Name: fr-CA-JeanNeural
+Gender: Male
+
+Name: fr-CA-SylvieNeural
+Gender: Female
+
+Name: fr-CA-ThierryNeural
+Gender: Male
+
+Name: fr-CH-ArianeNeural
+Gender: Female
+
+Name: fr-CH-FabriceNeural
+Gender: Male
+
+Name: fr-FR-DeniseNeural
+Gender: Female
+
+Name: fr-FR-EloiseNeural
+Gender: Female
+
+Name: fr-FR-HenriNeural
+Gender: Male
+
+Name: fr-FR-RemyMultilingualNeural
+Gender: Male
+
+Name: fr-FR-VivienneMultilingualNeural
+Gender: Female
+
+Name: ga-IE-ColmNeural
+Gender: Male
+
+Name: ga-IE-OrlaNeural
+Gender: Female
+
+Name: gl-ES-RoiNeural
+Gender: Male
+
+Name: gl-ES-SabelaNeural
+Gender: Female
+
+Name: gu-IN-DhwaniNeural
+Gender: Female
+
+Name: gu-IN-NiranjanNeural
+Gender: Male
+
+Name: he-IL-AvriNeural
+Gender: Male
+
+Name: he-IL-HilaNeural
+Gender: Female
+
+Name: hi-IN-MadhurNeural
+Gender: Male
+
+Name: hi-IN-SwaraNeural
+Gender: Female
+
+Name: hr-HR-GabrijelaNeural
+Gender: Female
+
+Name: hr-HR-SreckoNeural
+Gender: Male
+
+Name: hu-HU-NoemiNeural
+Gender: Female
+
+Name: hu-HU-TamasNeural
+Gender: Male
+
+Name: id-ID-ArdiNeural
+Gender: Male
+
+Name: id-ID-GadisNeural
+Gender: Female
+
+Name: is-IS-GudrunNeural
+Gender: Female
+
+Name: is-IS-GunnarNeural
+Gender: Male
+
+Name: it-IT-DiegoNeural
+Gender: Male
+
+Name: it-IT-ElsaNeural
+Gender: Female
+
+Name: it-IT-GiuseppeMultilingualNeural
+Gender: Male
+
+Name: it-IT-IsabellaNeural
+Gender: Female
+
+Name: iu-Cans-CA-SiqiniqNeural
+Gender: Female
+
+Name: iu-Cans-CA-TaqqiqNeural
+Gender: Male
+
+Name: iu-Latn-CA-SiqiniqNeural
+Gender: Female
+
+Name: iu-Latn-CA-TaqqiqNeural
+Gender: Male
+
+Name: ja-JP-KeitaNeural
+Gender: Male
+
+Name: ja-JP-NanamiNeural
+Gender: Female
+
+Name: jv-ID-DimasNeural
+Gender: Male
+
+Name: jv-ID-SitiNeural
+Gender: Female
+
+Name: ka-GE-EkaNeural
+Gender: Female
+
+Name: ka-GE-GiorgiNeural
+Gender: Male
+
+Name: kk-KZ-AigulNeural
+Gender: Female
+
+Name: kk-KZ-DauletNeural
+Gender: Male
+
+Name: km-KH-PisethNeural
+Gender: Male
+
+Name: km-KH-SreymomNeural
+Gender: Female
+
+Name: kn-IN-GaganNeural
+Gender: Male
+
+Name: kn-IN-SapnaNeural
+Gender: Female
+
+Name: ko-KR-HyunsuMultilingualNeural
+Gender: Male
+
+Name: ko-KR-InJoonNeural
+Gender: Male
+
+Name: ko-KR-SunHiNeural
+Gender: Female
+
+Name: lo-LA-ChanthavongNeural
+Gender: Male
+
+Name: lo-LA-KeomanyNeural
+Gender: Female
+
+Name: lt-LT-LeonasNeural
+Gender: Male
+
+Name: lt-LT-OnaNeural
+Gender: Female
+
+Name: lv-LV-EveritaNeural
+Gender: Female
+
+Name: lv-LV-NilsNeural
+Gender: Male
+
+Name: mk-MK-AleksandarNeural
+Gender: Male
+
+Name: mk-MK-MarijaNeural
+Gender: Female
+
+Name: ml-IN-MidhunNeural
+Gender: Male
+
+Name: ml-IN-SobhanaNeural
+Gender: Female
+
+Name: mn-MN-BataaNeural
+Gender: Male
+
+Name: mn-MN-YesuiNeural
+Gender: Female
+
+Name: mr-IN-AarohiNeural
+Gender: Female
+
+Name: mr-IN-ManoharNeural
+Gender: Male
+
+Name: ms-MY-OsmanNeural
+Gender: Male
+
+Name: ms-MY-YasminNeural
+Gender: Female
+
+Name: mt-MT-GraceNeural
+Gender: Female
+
+Name: mt-MT-JosephNeural
+Gender: Male
+
+Name: my-MM-NilarNeural
+Gender: Female
+
+Name: my-MM-ThihaNeural
+Gender: Male
+
+Name: nb-NO-FinnNeural
+Gender: Male
+
+Name: nb-NO-PernilleNeural
+Gender: Female
+
+Name: ne-NP-HemkalaNeural
+Gender: Female
+
+Name: ne-NP-SagarNeural
+Gender: Male
+
+Name: nl-BE-ArnaudNeural
+Gender: Male
+
+Name: nl-BE-DenaNeural
+Gender: Female
+
+Name: nl-NL-ColetteNeural
+Gender: Female
+
+Name: nl-NL-FennaNeural
+Gender: Female
+
+Name: nl-NL-MaartenNeural
+Gender: Male
+
+Name: pl-PL-MarekNeural
+Gender: Male
+
+Name: pl-PL-ZofiaNeural
+Gender: Female
+
+Name: ps-AF-GulNawazNeural
+Gender: Male
+
+Name: ps-AF-LatifaNeural
+Gender: Female
+
+Name: pt-BR-AntonioNeural
+Gender: Male
+
+Name: pt-BR-FranciscaNeural
+Gender: Female
+
+Name: pt-BR-ThalitaMultilingualNeural
+Gender: Female
+
+Name: pt-PT-DuarteNeural
+Gender: Male
+
+Name: pt-PT-RaquelNeural
+Gender: Female
+
+Name: ro-RO-AlinaNeural
+Gender: Female
+
+Name: ro-RO-EmilNeural
+Gender: Male
+
+Name: ru-RU-DmitryNeural
+Gender: Male
+
+Name: ru-RU-SvetlanaNeural
+Gender: Female
+
+Name: si-LK-SameeraNeural
+Gender: Male
+
+Name: si-LK-ThiliniNeural
+Gender: Female
+
+Name: sk-SK-LukasNeural
+Gender: Male
+
+Name: sk-SK-ViktoriaNeural
+Gender: Female
+
+Name: sl-SI-PetraNeural
+Gender: Female
+
+Name: sl-SI-RokNeural
+Gender: Male
+
+Name: so-SO-MuuseNeural
+Gender: Male
+
+Name: so-SO-UbaxNeural
+Gender: Female
+
+Name: sq-AL-AnilaNeural
+Gender: Female
+
+Name: sq-AL-IlirNeural
+Gender: Male
+
+Name: sr-RS-NicholasNeural
+Gender: Male
+
+Name: sr-RS-SophieNeural
+Gender: Female
+
+Name: su-ID-JajangNeural
+Gender: Male
+
+Name: su-ID-TutiNeural
+Gender: Female
+
+Name: sv-SE-MattiasNeural
+Gender: Male
+
+Name: sv-SE-SofieNeural
+Gender: Female
+
+Name: sw-KE-RafikiNeural
+Gender: Male
+
+Name: sw-KE-ZuriNeural
+Gender: Female
+
+Name: sw-TZ-DaudiNeural
+Gender: Male
+
+Name: sw-TZ-RehemaNeural
+Gender: Female
+
+Name: ta-IN-PallaviNeural
+Gender: Female
+
+Name: ta-IN-ValluvarNeural
+Gender: Male
+
+Name: ta-LK-KumarNeural
+Gender: Male
+
+Name: ta-LK-SaranyaNeural
+Gender: Female
+
+Name: ta-MY-KaniNeural
+Gender: Female
+
+Name: ta-MY-SuryaNeural
+Gender: Male
+
+Name: ta-SG-AnbuNeural
+Gender: Male
+
+Name: ta-SG-VenbaNeural
+Gender: Female
+
+Name: te-IN-MohanNeural
+Gender: Male
+
+Name: te-IN-ShrutiNeural
+Gender: Female
+
+Name: th-TH-NiwatNeural
+Gender: Male
+
+Name: th-TH-PremwadeeNeural
+Gender: Female
+
+Name: tr-TR-AhmetNeural
+Gender: Male
+
+Name: tr-TR-EmelNeural
+Gender: Female
+
+Name: uk-UA-OstapNeural
+Gender: Male
+
+Name: uk-UA-PolinaNeural
+Gender: Female
+
+Name: ur-IN-GulNeural
+Gender: Female
+
+Name: ur-IN-SalmanNeural
+Gender: Male
+
+Name: ur-PK-AsadNeural
+Gender: Male
+
+Name: ur-PK-UzmaNeural
+Gender: Female
+
+Name: uz-UZ-MadinaNeural
+Gender: Female
+
+Name: uz-UZ-SardorNeural
+Gender: Male
+
+Name: vi-VN-HoaiMyNeural
+Gender: Female
+
+Name: vi-VN-NamMinhNeural
+Gender: Male
+
+Name: zh-CN-XiaoxiaoNeural
+Gender: Female
+
+Name: zh-CN-XiaoyiNeural
+Gender: Female
+
+Name: zh-CN-YunjianNeural
+Gender: Male
+
+Name: zh-CN-YunxiNeural
+Gender: Male
+
+Name: zh-CN-YunxiaNeural
+Gender: Male
+
+Name: zh-CN-YunyangNeural
+Gender: Male
+
+Name: zh-CN-liaoning-XiaobeiNeural
+Gender: Female
+
+Name: zh-CN-shaanxi-XiaoniNeural
+Gender: Female
+
+Name: zh-HK-HiuGaaiNeural
+Gender: Female
+
+Name: zh-HK-HiuMaanNeural
+Gender: Female
+
+Name: zh-HK-WanLungNeural
+Gender: Male
+
+Name: zh-TW-HsiaoChenNeural
+Gender: Female
+
+Name: zh-TW-HsiaoYuNeural
+Gender: Female
+
+Name: zh-TW-YunJheNeural
+Gender: Male
+
+Name: zu-ZA-ThandoNeural
+Gender: Female
+
+Name: zu-ZA-ThembaNeural
+Gender: Male
+    """.strip()
+    voices = []
+    name = ""
+    for line in voices_str.split("\n"):
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith("Name: "):
+            name = line[6:].strip()
+        if line.startswith("Gender: "):
+            gender = line[8:].strip()
+            if name and gender:
+                # voices.append({
+                #     "name": name,
+                #     "gender": gender,
+                # })
+                if filter_locals:
+                    for filter_local in filter_locals:
+                        if name.lower().startswith(filter_local.lower()):
+                            voices.append(f"{name}-{gender}")
+                else:
+                    voices.append(f"{name}-{gender}")
+                name = ""
+    voices.sort()
+    return voices
+
+
+def parse_voice_name(name: str):
+    # zh-CN-XiaoyiNeural-Female
+    # zh-CN-YunxiNeural-Male
+    # zh-CN-XiaoxiaoMultilingualNeural-V2-Female
+    name = name.replace("-Female", "").replace("-Male", "").strip()
+    return name
+
+
+def convert_rate_to_percent(rate: float) -> str:
+    if rate == 1.0:
+        return "+0%"
+    percent = round((rate - 1.0) * 100)
+    if percent > 0:
+        return f"+{percent}%"
+    else:
+        return f"{percent}%"
+
+
+async def generate_voice(text: str, voice_name: str, voice_rate: float = 0, audio_file: str = None, subtitle_file: str = None) -> Tuple[str, str]:
+    """生成语音和字幕
+
+    Args:
+        text (str): 文本内容
+        voice_name (str): 语音名称
+        voice_rate (float, optional): 语音速率. Defaults to 0.
+        audio_file (str, optional): 语音文件路径. Defaults to None.
+        subtitle_file (str, optional): 字幕文件路径. Defaults to None.
+
+    Returns:
+        Tuple[str, str]: 语音文件路径, 字幕文件路径
+    """
+    if audio_file is None:
+        audio_file = f"temp_{uuid.uuid4()}.mp3"
+    if subtitle_file is None:
+        subtitle_file = f"temp_{uuid.uuid4()}.srt"
+
+    # 生成语音
+    sub_maker = await edge_tts_voice(text, voice_name, audio_file, voice_rate)
+    # 生成字幕
+    if sub_maker:
+        await generate_subtitle(sub_maker, text, subtitle_file)
+    else:
+        logger.error("Failed to generate sub_maker")
+    
+    return audio_file, subtitle_file
+
+
+async def edge_tts_voice(text: str, voice_name: str, voice_file: str, voice_rate: float = 0) -> SubMaker:
+    """使用 Edge TTS 生成语音"""
+    rate_str = convert_rate_to_percent(voice_rate)
+    for i in range(3):
+        try:
+            logger.info(f"start, voice name: {voice_name}, try: {i + 1}")
+
+            communicate = edge_tts.Communicate(text, voice_name, rate=rate_str)
+            sub_maker = edge_tts.SubMaker()
+            
+            with open(voice_file, "wb") as file:
+                async for chunk in communicate.stream():
+                    if chunk["type"] == "audio":
+                        file.write(chunk["data"])
+                    elif chunk["type"] == "WordBoundary":
+                        logger.debug(f"Got word boundary: {chunk}")
+                        # 使用 SubMaker 的 create_sub 方法创建字幕
+                        sub_maker.create_sub((chunk["offset"], chunk["duration"]), chunk["text"])
+
+            if not sub_maker or not sub_maker.subs:
+                logger.warning("failed, sub_maker is None or sub_maker.subs is None")
+                continue
+
+            logger.info(f"completed, output file: {voice_file}")
+            return sub_maker
+        except Exception as e:
+            logger.error(f"failed, error: {str(e)}")
+            continue
+    return None
+
+
+async def generate_subtitle(sub_maker: edge_tts.SubMaker, text: str, subtitle_file: str):
+    """生成字幕文件"""
+    try:
+        if not sub_maker or not hasattr(sub_maker, "subs") or not sub_maker.subs:
+            print("No subtitles to generate: sub_maker is None or sub_maker.subs is empty")
+            return
+
+        print(f"Generating subtitles with {len(sub_maker.subs)} items")
+        
+        # 直接使用创建字幕的函数
+        await create_subtitle(sub_maker=sub_maker, text=text, subtitle_file=subtitle_file)
+            
+    except Exception as e:
+        print(f"failed to generate subtitle: {str(e)}")
+        import traceback
+        print(traceback.format_exc())
+
+
+def get_audio_duration(sub_maker: edge_tts.SubMaker) -> float:
+    """获取音频时长（秒）"""
+    if not sub_maker or not hasattr(sub_maker, "subs") or not sub_maker.subs:
+        return 0
+    last_sub = sub_maker.subs[-1]
+    start, duration = last_sub[0]
+    return (start + duration) / 10000000  # 转换为秒
+
+
+def _format_text(text: str) -> str:
+    text = text.replace("[", " ")
+    text = text.replace("]", " ")
+    text = text.replace("(", " ")
+    text = text.replace(")", " ")
+    text = text.replace("{", " ")
+    text = text.replace("}", " ")
+    text = text.strip()
+    return text
+
+
+
+
+async def create_subtitle(sub_maker: edge_tts.SubMaker, text: str, subtitle_file: str):
+    """
+    优化字幕文件
+    1. 将字幕文件按照标点符号分割成多行
+    2. 逐行匹配字幕文件中的文本
+    3. 生成新的字幕文件
+    """
+    text = _format_text(text)
+
+    def formatter(idx: int, start_time: float, end_time: float, sub_text: str) -> str:
+        """
+        1
+        00:00:00,000 --> 00:00:02,360
+        跑步是一项简单易行的运动
+        """
+        start_t = mktimestamp(start_time).replace(".", ",")
+        end_t = mktimestamp(end_time).replace(".", ",")
+        return f"{idx}\n{start_t} --> {end_t}\n{sub_text}\n"
+
+    start_time = -1.0
+    sub_items = []
+    sub_index = 0
+
+    script_lines = split_string_by_punctuations(text)
+    logger.debug(f"Split text into {len(script_lines)} lines: {script_lines}")
+
+    def match_line(_sub_line: str, _sub_index: int):
+        if len(script_lines) <= _sub_index:
+            return ""
+
+        _line = script_lines[_sub_index]
+        if _sub_line == _line:
+            return script_lines[_sub_index].strip()
+
+        _sub_line_ = re.sub(r"[^\w\s]", "", _sub_line)
+        _line_ = re.sub(r"[^\w\s]", "", _line)
+        if _sub_line_ == _line_:
+            return _line_.strip()
+
+        _sub_line_ = re.sub(r"\W+", "", _sub_line)
+        _line_ = re.sub(r"\W+", "", _line)
+        if _sub_line_ == _line_:
+            return _line.strip()
+
+        return ""
+
+    sub_line = ""
+
+    try:
+        for _, (offset, sub) in enumerate(zip(sub_maker.offset, sub_maker.subs)):
+            _start_time, end_time = offset
+            if start_time < 0:
+                start_time = _start_time
+
+            sub = unescape(sub)
+            sub_line += sub
+            sub_text = match_line(sub_line, sub_index)
+            if sub_text:
+                sub_index += 1
+                line = formatter(
+                    idx=sub_index,
+                    start_time=start_time,
+                    end_time=end_time,
+                    sub_text=sub_text,
+                )
+                sub_items.append(line)
+                start_time = -1.0
+                sub_line = ""
+        if len(sub_items) == len(script_lines):
+            with open(subtitle_file, "w", encoding="utf-8") as file:
+                file.write("\n".join(sub_items) + "\n")
+            try:
+                sbs = subtitles.file_to_subtitles(subtitle_file, encoding="utf-8")
+                duration = max([tb for ((ta, tb), txt) in sbs])
+                logger.info(
+                    f"completed, subtitle file created: {subtitle_file}, duration: {duration}"
+                )
+            except Exception as e:
+                logger.error(f"failed, error: {str(e)}")
+                os.remove(subtitle_file)
+        else:
+            logger.error(
+                f"failed, sub_items len: {len(sub_items)}, script_lines len: {len(script_lines)}"
+            )
+
+    except Exception as e:
+        logger.error(f"failed, error: {str(e)}")

app/utils/__init__.py

@@ -0,0 +1 @@
+

app/utils/utils.py

@@ -0,0 +1,248 @@
+import json
+import locale
+import os
+import random
+import re
+import string
+import threading
+import urllib3
+from typing import Any, List
+from uuid import uuid4
+from pathlib import Path
+
+from loguru import logger
+
+from app.models import const
+
+urllib3.disable_warnings()
+
+
+def get_uuid(remove_hyphen: bool = False):
+    u = str(uuid4())
+    if remove_hyphen:
+        u = u.replace("-", "")
+    return u
+
+
+def get_root_dir():
+    return os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+
+
+def resource_dir(sub_dir: str = ""):
+    d = os.path.join(get_root_dir(), "resource")
+    if sub_dir:
+        d = os.path.join(d, sub_dir)
+    return d
+
+def task_dir(sub_dir: str = "") -> str:
+    """获取任务目录路径
+    Args:
+        sub_dir (str, optional): 子目录名. Defaults to "".
+    Returns:
+        str: 任务目录的绝对路径
+    """
+    # 获取 backend 目录
+    root_dir = get_root_dir()
+    # 任务目录
+    d = os.path.join(root_dir, "tasks")
+    if sub_dir:
+        d = os.path.join(d, sub_dir)
+    
+    # 确保目录存在
+    os.makedirs(d, exist_ok=True)
+    
+    return d
+
+
+def font_dir(sub_dir: str = ""):
+    d = resource_dir("fonts")
+    if sub_dir:
+        d = os.path.join(d, sub_dir)
+    if not os.path.exists(d):
+        os.makedirs(d)
+    return d
+
+
+def song_dir(sub_dir: str = ""):
+    d = resource_dir("songs")
+    if sub_dir:
+        d = os.path.join(d, sub_dir)
+    if not os.path.exists(d):
+        os.makedirs(d)
+    return d
+
+
+def public_dir(sub_dir: str = ""):
+    d = resource_dir("public")
+    if sub_dir:
+        d = os.path.join(d, sub_dir)
+    if not os.path.exists(d):
+        os.makedirs(d)
+    return d
+
+
+def run_in_background(func, *args, **kwargs):
+    def run():
+        try:
+            func(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"run_in_background error: {e}")
+
+    thread = threading.Thread(target=run)
+    thread.start()
+    return thread
+
+
+def time_convert_seconds_to_hmsm(seconds) -> str:
+    hours = int(seconds // 3600)
+    seconds = seconds % 3600
+    minutes = int(seconds // 60)
+    milliseconds = int(seconds * 1000) % 1000
+    seconds = int(seconds % 60)
+    return "{:02d}:{:02d}:{:02d},{:03d}".format(hours, minutes, seconds, milliseconds)
+
+
+def text_to_srt(idx: int, msg: str, start_time: float, end_time: float) -> str:
+    start_time = time_convert_seconds_to_hmsm(start_time)
+    end_time = time_convert_seconds_to_hmsm(end_time)
+    srt = """%d
+%s --> %s
+%s
+        """ % (
+        idx,
+        start_time,
+        end_time,
+        msg,
+    )
+    return srt
+
+
+def str_contains_punctuation(word):
+    for p in const.PUNCTUATIONS:
+        if p in word:
+            return True
+    return False
+
+
+def split_string_by_punctuations(s):
+    result = []
+    txt = ""
+
+    previous_char = ""
+    next_char = ""
+    for i in range(len(s)):
+        char = s[i]
+        if char == "\n":
+            result.append(txt.strip())
+            txt = ""
+            continue
+
+        if i > 0:
+            previous_char = s[i - 1]
+        if i < len(s) - 1:
+            next_char = s[i + 1]
+
+        if char == "." and previous_char.isdigit() and next_char.isdigit():
+            # # In the case of "withdraw 10,000, charged at 2.5% fee", the dot in "2.5" should not be treated as a line break marker
+            txt += char
+            continue
+
+        if char not in const.PUNCTUATIONS:
+            txt += char
+        else:
+            result.append(txt.strip())
+            txt = ""
+    result.append(txt.strip())
+    # filter empty string
+    result = list(filter(None, result))
+    return result
+
+
+def split_string_by_punctuations_new(text: str) -> List[str]:
+    """按标点符号分割文本"""
+    result = []
+    txt = ""
+
+    previous_char = ""
+    next_char = ""
+    for i in range(len(text)):
+        char = text[i]
+        if char == "\n":
+            if txt.strip():
+                result.append(txt.strip())
+            txt = ""
+            continue
+
+        if i > 0:
+            previous_char = text[i - 1]
+        if i < len(text) - 1:
+            next_char = text[i + 1]
+
+        if char == "." and previous_char.isdigit() and next_char.isdigit():
+            txt += char
+            continue
+
+        if char not in [".", "。", "！", "？", "...", "…"]:
+            txt += char
+        else:
+            txt += char
+            if txt.strip():
+                result.append(txt.strip())
+            txt = ""
+
+    if txt.strip():
+        result.append(txt.strip())
+    return result
+
+
+def random_str(length: int = 8) -> str:
+    """生成随机字符串"""
+    letters = string.ascii_lowercase + string.digits
+    return ''.join(random.choice(letters) for _ in range(length))
+
+
+def md5(text):
+    import hashlib
+
+    return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+
+def get_system_locale():
+    try:
+        loc = locale.getdefaultlocale()
+        # zh_CN, zh_TW return zh
+        # en_US, en_GB return en
+        language_code = loc[0].split("_")[0]
+        return language_code
+    except Exception:
+        return "en"
+
+
+def load_locales(i18n_dir):
+    _locales = {}
+    for root, dirs, files in os.walk(i18n_dir):
+        for file in files:
+            if file.endswith(".json"):
+                lang = file.split(".")[0]
+                with open(os.path.join(root, file), "r", encoding="utf-8") as f:
+                    _locales[lang] = json.loads(f.read())
+    return _locales
+
+
+def parse_extension(filename):
+    return os.path.splitext(filename)[1].strip().lower().replace(".", "")
+
+def extract_id(video_file: str) -> str:
+    """
+    从路径中提取 ID（tasks 目录下的第一级子目录名）
+    兼容 Windows 和 Linux
+    """
+    path = Path(video_file)
+
+    # 遍历路径的所有部分，查找 "tasks" 目录
+    try:
+        parts = path.parts
+        index = parts.index("tasks")  # 找到 "tasks" 目录的位置
+        return parts[index + 1]  # 返回紧跟其后的部分作为 ID
+    except (ValueError, IndexError):
+        raise ValueError(f"Invalid path format: {video_file}")

main.py

@@ -0,0 +1,40 @@
+from fastapi import FastAPI, APIRouter
+from fastapi.staticfiles import StaticFiles
+
+from fastapi.middleware.cors import CORSMiddleware
+from app.api import api_router
+import os
+
+app = FastAPI(
+    title="StoryFlicks Backend API",
+    description="Backend API for StoryFlicks application",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173", "http://127.0.0.1:5173"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+if not os.path.exists('tasks'):
+    os.makedirs('tasks')
+
+app.mount("/tasks", StaticFiles(directory=os.path.abspath("tasks")), name="tasks")
+# Include API router
+app.include_router(api_router)
+
+@app.get("/")
+async def root():
+    return {
+        "app_name": "StoryFlicks Backend API",
+        "docs_url": "/docs"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

requirements.txt

@@ -0,0 +1,16 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+python-multipart==0.0.6
+pydantic==2.5.2
+pydantic-settings==2.1.0
+python-dotenv==1.0.0
+openai==1.59.7
+dashscope==1.22.0
+edge_tts==6.1.19
+loguru==0.7.2
+numpy==1.25.0
+moviepy==2.1.1
+decorator==4.4.2
+imageio-ffmpeg==0.4.9
+requests==2.31.0
+Pillow==9.5.0

resource/fonts/MicrosoftYaHeiBold.ttc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:519309b7ab0479c4dc3ace5e291de5a8702175be5586e165bc810267bd4619a5
+size 16880832

resource/fonts/MicrosoftYaHeiNormal.ttc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3084f1f88369af6bf9989c909024164d953d1e38d08734f05f28ef24b2f9d577
+size 19701556

resource/fonts/STHeitiLight.ttc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a57b0316cc0544f682b8fb9855e14ade79ae77340ef6a01ba9210e25b4c5a5b7
+size 55783456

resource/fonts/STHeitiMedium.ttc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8fa4a63e2cf500e98e64d4c73260daaba049306cf85dec9e3729bc285b7d645
+size 55754164