Upload 3 files

Dockerfile

@@ -16,7 +16,8 @@ RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
 
 # 创建必要的目录
-RUN mkdir -p temp
+RUN mkdir -p temp && chmod 777 temp
+RUN mkdir -p storage && chmod 777 storage
 
 # 暴露端口
 EXPOSE 8000

app.py

@@ -1,7 +1,7 @@
 from fastapi import FastAPI, HTTPException, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from typing import List
+from typing import List, Dict
 import os
 import uuid
 import aiohttp
@@ -10,9 +10,12 @@ import logging
 import tempfile
 import openai
 from pathlib import Path
-import webdav3.client as wc
 import subprocess
 import shutil
+import ssl
+import json
+from fastapi.staticfiles import StaticFiles
+from pydub import AudioSegment
 
 # 配置日志
 logging.basicConfig(level=logging.INFO)
@@ -21,9 +24,7 @@ logger = logging.getLogger(__name__)
 # 环境变量
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
-WEBDAV_URL = os.getenv("WEBDAV_URL")
-WEBDAV_USERNAME = os.getenv("WEBDAV_USERNAME")
-WEBDAV_PASSWORD = os.getenv("WEBDAV_PASSWORD")
+BASE_URL = os.getenv("BASE_URL", "http://localhost:8000")
 
 # 初始化OpenAI
 openai.api_key = OPENAI_API_KEY
@@ -32,6 +33,8 @@ if OPENAI_BASE_URL:
 
 app = FastAPI()
 
+app.mount("/storage", StaticFiles(directory="storage"), name="storage")
+
 # 配置CORS
 app.add_middleware(
     CORSMiddleware,
@@ -47,26 +50,23 @@ class ComicData(BaseModel):
     speeches: List[str]
     panels: List[str]  # 图片URLs
 
-# WebDAV客户端配置
-def get_webdav_client():
-    options = {
-        'webdav_hostname': WEBDAV_URL,
-        'webdav_login': WEBDAV_USERNAME,
-        'webdav_password': WEBDAV_PASSWORD
-    }
-    return wc.Client(options)
-
 # 下载图片
-async def download_image(session, url, output_path):
+async def download_image(url, output_path):
     try:
-        async with session.get(url) as response:
-            if response.status == 200:
-                with open(output_path, 'wb') as f:
-                    f.write(await response.read())
-                return output_path
-            else:
-                logger.error(f"Failed to download image: {response.status}")
-                return None
+        # 创建一个不验证SSL的TCP连接器
+        ssl_context = ssl.create_default_context()
+        ssl_context.check_hostname = False
+        ssl_context.verify_mode = ssl.CERT_NONE
+        
+        async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=ssl_context)) as session:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    with open(output_path, 'wb') as f:
+                        f.write(await response.read())
+                    return output_path
+                else:
+                    logger.error(f"Failed to download image: {response.status}")
+                    return None
     except Exception as e:
         logger.error(f"Error downloading image: {e}")
         return None
@@ -77,87 +77,80 @@ async def generate_speech(text, voice="alloy", output_path=None):
         if not output_path:
             output_path = f"{uuid.uuid4()}.mp3"
         
-        response = await openai.audio.speech.create(
+        response = openai.audio.speech.create(
             model="tts-1",
             voice=voice,
             input=text
         )
         
-        response.stream_to_file(output_path)
+        # 直接将内容写入文件
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+
         return output_path
     except Exception as e:
         logger.error(f"Error generating speech: {e}")
         return None
 
-# 创建视频
-def create_video(project_dir, image_paths, subtitle_file, audio_file, output_video):
+# 获取音频文件时长
+def get_audio_duration(audio_path):
     try:
-        # 创建帧列表文件
-        frames_list = os.path.join(project_dir, "frames.txt")
-        with open(frames_list, "w") as f:
-            for img in image_paths:
-                # 每个图片显示5秒
-                f.write(f"file '{img}'\n")
-                f.write(f"duration 5\n")
-            # 最后一张图片需要单独添加，否则会被忽略
-            f.write(f"file '{image_paths[-1]}'\n")
+        audio = AudioSegment.from_file(audio_path)
+        return len(audio) / 1000.0  # 转换为秒
+    except Exception as e:
+        logger.error(f"Error getting audio duration: {e}")
+        return 5.0  # 默认5秒
+
+# 创建caption字幕文件（底部显示）
+def create_caption_subtitle_file(project_dir, captions, panel_start_times, panel_durations):
+    try:
+        subtitle_file = os.path.join(project_dir, "captions.srt")
         
-        # 使用FFmpeg创建视频
-        cmd = [
-            "ffmpeg", "-y",
-            "-f", "concat", "-safe", "0", "-i", frames_list,
-            "-i", audio_file,
-            "-vf", f"subtitles={subtitle_file}",
-            "-c:v", "libx264", "-pix_fmt", "yuv420p",
-            "-c:a", "aac", "-strict", "experimental",
-            output_video
-        ]
+        with open(subtitle_file, "w", encoding="utf-8") as f:
+            subtitle_index = 1
+            
+            # 处理每个面板的旁白字幕
+            for i, caption in enumerate(captions):
+                # 获取当前面板的开始时间和持续时间
+                start_time = panel_start_times[i]
+                duration = panel_durations[i]
+                end_time = start_time + duration
+                
+                # 字幕显示整个面板的时长
+                f.write(f"{subtitle_index}\n")
+                f.write(f"{format_time(start_time)} --> {format_time(end_time)}\n")
+                f.write(f"{caption}\n\n")
+                subtitle_index += 1
         
-        subprocess.run(cmd, check=True)
-        return output_video
+        return subtitle_file
     except Exception as e:
-        logger.error(f"Error creating video: {e}")
+        logger.error(f"Error creating caption subtitle file: {e}")
         return None
 
-# 创建字幕文件
-def create_subtitle_file(project_dir, captions, speeches):
+# 创建speech字幕文件（顶部显示）
+def create_speech_subtitle_file(project_dir, speeches, panel_start_times, panel_durations):
     try:
-        subtitle_file = os.path.join(project_dir, "subtitles.srt")
+        subtitle_file = os.path.join(project_dir, "speeches.srt")
         
         with open(subtitle_file, "w", encoding="utf-8") as f:
             subtitle_index = 1
-            current_time = 0
             
-            # 处理每个面板的字幕和对话
-            for i, (caption, speech) in enumerate(zip(captions, speeches)):
-                # 每个面板展示5秒
-                panel_duration = 5
+            # 处理每个面板的对话字幕
+            for i, speech in enumerate(speeches):
+                # 获取当前面板的开始时间和持续时间
+                start_time = panel_start_times[i]
+                duration = panel_durations[i]
+                end_time = start_time + duration
                 
-                # 字幕开始和结束时间
-                start_time = current_time
-                
-                # 字幕显示
-                if caption:
-                    end_time = start_time + 2.5
-                    f.write(f"{subtitle_index}\n")
-                    f.write(f"{format_time(start_time)} --> {format_time(end_time)}\n")
-                    f.write(f"{caption}\n\n")
-                    subtitle_index += 1
-                
-                # 对话显示
-                if speech:
-                    speech_start = start_time + 2.5 if caption else start_time
-                    speech_end = current_time + panel_duration
-                    f.write(f"{subtitle_index}\n")
-                    f.write(f"{format_time(speech_start)} --> {format_time(speech_end)}\n")
-                    f.write(f"{speech}\n\n")
-                    subtitle_index += 1
-                
-                current_time += panel_duration
+                # 字幕显示整个面板的时长
+                f.write(f"{subtitle_index}\n")
+                f.write(f"{format_time(start_time)} --> {format_time(end_time)}\n")
+                f.write(f"{speech}\n\n")
+                subtitle_index += 1
         
         return subtitle_file
     except Exception as e:
-        logger.error(f"Error creating subtitle file: {e}")
+        logger.error(f"Error creating speech subtitle file: {e}")
         return None
 
 # 格式化时间为SRT格式
@@ -172,131 +165,273 @@ def format_time(seconds):
 async def create_audio_file(project_dir, captions, speeches):
     try:
         audio_parts = []
+        audio_durations = {}
+        panel_start_times = [0]  # 第一个面板从0秒开始
         current_time = 0
+        panel_durations = []
         
         # 为每个面板生成音频
         for i, (caption, speech) in enumerate(zip(captions, speeches)):
+            panel_audio_parts = []
+            panel_duration = 0
+            
             # 每个面板的旁白
             if caption:
                 caption_audio = os.path.join(project_dir, f"caption_{i}.mp3")
-                await generate_speech(caption, "alloy", caption_audio)
-                audio_parts.append(caption_audio)
+                result = await generate_speech(caption, "alloy", caption_audio)
+                if result:
+                    duration = get_audio_duration(caption_audio)
+                    audio_durations[f"caption_{i}"] = duration
+                    panel_audio_parts.append(caption_audio)
+                    panel_duration += duration
             
             # 每个面板的对话
             if speech:
                 speech_audio = os.path.join(project_dir, f"speech_{i}.mp3")
-                await generate_speech(speech, "echo", speech_audio)
-                audio_parts.append(speech_audio)
+                result = await generate_speech(speech, "nova", speech_audio)
+                if result:
+                    duration = get_audio_duration(speech_audio)
+                    audio_durations[f"speech_{i}"] = duration
+                    panel_audio_parts.append(speech_audio)
+                    panel_duration += duration
+            
+            # 确保每个面板至少有最小时长
+            if panel_duration == 0:
+                panel_duration = 5.0  # 默认5秒
+            
+            panel_durations.append(panel_duration)
+            
+            # 合并当前面板的音频（先caption后speech）
+            if panel_audio_parts:
+                panel_combined = os.path.join(project_dir, f"panel_{i}_combined.mp3")
+                combined = AudioSegment.empty()
+                
+                for audio_path in panel_audio_parts:
+                    segment = AudioSegment.from_file(audio_path)
+                    combined += segment
+                
+                combined.export(panel_combined, format="mp3")
+                audio_parts.append(panel_combined)
+            
+            # 更新下一个面板的开始时间
+            current_time += panel_duration
+            if i < len(captions) - 1:  # 不是最后一个面板
+                panel_start_times.append(current_time)
         
-        # 合并所有音频部分
+        if not audio_parts:
+            logger.error("No audio parts generated")
+            return None, {}, [], []
+            
+        # 合并所有面板的音频
         combined_audio = os.path.join(project_dir, "combined_audio.mp3")
+        final_combined = AudioSegment.empty()
+        
+        for audio_path in audio_parts:
+            segment = AudioSegment.from_file(audio_path)
+            final_combined += segment
+        
+        final_combined.export(combined_audio, format="mp3")
         
-        # 使用FFmpeg合并音频
-        audio_list = os.path.join(project_dir, "audio_list.txt")
-        with open(audio_list, "w") as f:
-            for audio in audio_parts:
-                f.write(f"file '{audio}'\n")
+        # 保存音频时长信息
+        durations_file = os.path.join(project_dir, "audio_durations.json")
+        with open(durations_file, "w") as f:
+            json.dump(audio_durations, f)
         
-        subprocess.run([
-            "ffmpeg", "-y", "-f", "concat", "-safe", "0",
-            "-i", audio_list, "-c", "copy", combined_audio
-        ], check=True)
+        # 保存面板开始时间信息
+        panel_times_file = os.path.join(project_dir, "panel_times.json")
+        with open(panel_times_file, "w") as f:
+            json.dump({"start_times": panel_start_times, "durations": panel_durations}, f)
         
-        return combined_audio
+        return combined_audio, audio_durations, panel_start_times, panel_durations
     except Exception as e:
         logger.error(f"Error creating audio file: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
+        return None, {}, [], []
+
+# 创建视频
+def create_video(project_dir, image_paths, caption_subtitle_file, speech_subtitle_file, audio_file, output_video, audio_durations, panel_start_times, panel_durations):
+    try:
+        # 创建帧列表文件 - 使用精确的面板持续时间
+        frames_list = os.path.join(project_dir, "frames.txt")
+        with open(frames_list, "w") as f:
+            for i, (img, duration) in enumerate(zip(image_paths, panel_durations)):
+                f.write(f"file '{img.replace(os.sep, '/')}'\n")
+                f.write(f"duration {duration}\n")
+            
+            # 最后一张图片需要单独添加，否则会被忽略
+            f.write(f"file '{image_paths[-1].replace(os.sep, '/')}'\n")
+        
+        # 先创建无字幕的视频 - 使用更精确的同步选项
+        temp_video = os.path.join(project_dir, "temp_video.mp4")
+        cmd1 = [
+            "ffmpeg", "-y",
+            "-f", "concat", "-safe", "0", "-i", frames_list,
+            "-i", audio_file,
+            "-c:v", "libx264", "-pix_fmt", "yuv420p",
+            "-c:a", "aac", "-strict", "experimental",
+            "-vsync", "vfr",  # 确保视频帧率与时间轴匹配
+            "-async", "1",    # 音频同步
+            temp_video
+        ]
+        
+        subprocess.run(cmd1, check=True)
+        
+        # 然后添加字幕 - 先添加caption字幕（底部）
+        temp_video2 = os.path.join(project_dir, "temp_video2.mp4")
+        caption_filter = f"subtitles='{caption_subtitle_file.replace(os.sep, '/').replace(':', '\\:')}':force_style='Fontname=Consolas,Alignment=2,FontSize=15,PrimaryColour=&H00E0FFFF,OutlineColour=&H80000000,BackColour=&H40000000,BorderStyle=1,Outline=0.8,Shadow=0.5,MarginV=10'"
+        
+        cmd2 = [
+            "ffmpeg", "-y",
+            "-i", temp_video,
+            "-vf", caption_filter,
+            "-c:a", "copy",
+            temp_video2
+        ]
+        
+        subprocess.run(cmd2, check=True)
+        
+        # 再��加speech字幕（顶部）
+        speech_filter = f"subtitles='{speech_subtitle_file.replace(os.sep, '/').replace(':', '\\:')}':force_style='Fontname=Consolas,Alignment=6,FontSize=15,PrimaryColour=&H00FFCCE6,OutlineColour=&H80000000,BackColour=&H40000000,BorderStyle=1,Outline=0.8,Shadow=0.5,MarginV=10,MarginR=15'"
+        
+        cmd3 = [
+            "ffmpeg", "-y",
+            "-i", temp_video2,
+            "-vf", speech_filter,
+            "-c:a", "copy",
+            output_video
+        ]
+        
+        subprocess.run(cmd3, check=True)
+        
+        # 删除临时文件
+        os.remove(temp_video)
+        os.remove(temp_video2)
+        
+        return output_video
+    except Exception as e:
+        logger.error(f"Error creating video: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
         return None
 
-# 上传到WebDAV
-def upload_to_webdav(local_path, remote_path):
+# 使用本地存储
+def upload_to_local_storage(local_path, relative_path):
     try:
-        client = get_webdav_client()
+        # 创建存储目录
+        storage_dir = os.path.abspath("storage")
+        os.makedirs(storage_dir, exist_ok=True)
+        
+        # 构建目标路径
+        target_dir = os.path.dirname(os.path.join(storage_dir, relative_path))
+        os.makedirs(target_dir, exist_ok=True)
         
-        # 确保远程目录存在
-        remote_dir = os.path.dirname(remote_path)
-        if not client.check(remote_dir):
-            client.mkdir(remote_dir)
+        target_path = os.path.join(storage_dir, relative_path)
         
-        # 上传文件
-        client.upload_sync(local_path=local_path, remote_path=remote_path)
+        # 复制文件
+        shutil.copy2(local_path, target_path)
         
-        # 获取公共URL
-        return f"{WEBDAV_URL}/{remote_path}"
+        # 返回完整URL
+        relative_url = f"/storage/{relative_path.replace(os.sep, '/')}"
+        full_url = f"{BASE_URL}{relative_url}"
+        return full_url
     except Exception as e:
-        logger.error(f"Error uploading to WebDAV: {e}")
+        logger.error(f"Error copying to local storage: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
         return None
 
 @app.post("/api/generate-video")
 async def generate_video(comic_data: ComicData, background_tasks: BackgroundTasks):
     # 创建唯一项目ID
     project_id = str(uuid.uuid4())
-    project_dir = f"temp/{project_id}"
+    # 使用绝对路径创建项目目录
+    project_dir = os.path.abspath(os.path.join("temp", project_id))
     os.makedirs(project_dir, exist_ok=True)
     
+    logger.info(f"Created project directory: {project_dir}")
+    
     try:
         # 下载图片
         image_paths = []
-        async with aiohttp.ClientSession() as session:
-            download_tasks = []
-            for i, panel_url in enumerate(comic_data.panels):
-                output_path = os.path.join(project_dir, f"panel_{i}.jpg")
-                download_tasks.append(download_image(session, panel_url, output_path))
-            
-            image_paths = await asyncio.gather(*download_tasks)
-            image_paths = [p for p in image_paths if p]  # 过滤失败的下载
+        for i, panel_url in enumerate(comic_data.panels):
+            output_path = os.path.join(project_dir, f"panel_{i}.jpg")
+            result = await download_image(panel_url, output_path)
+            if result:
+                image_paths.append(result)
         
         if not image_paths:
             raise HTTPException(status_code=500, detail="Failed to download images")
         
-        # 创建字幕文件
-        subtitle_file = create_subtitle_file(project_dir, comic_data.captions, comic_data.speeches)
-        if not subtitle_file:
-            raise HTTPException(status_code=500, detail="Failed to create subtitle file")
+        logger.info(f"Downloaded {len(image_paths)} images")
         
         # 创建音频文件
-        audio_file = await create_audio_file(project_dir, comic_data.captions, comic_data.speeches)
+        audio_file, audio_durations, panel_start_times, panel_durations = await create_audio_file(
+            project_dir, comic_data.captions, comic_data.speeches
+        )
         if not audio_file:
             raise HTTPException(status_code=500, detail="Failed to create audio file")
         
+        logger.info(f"Created audio file: {audio_file}")
+        
+        # 创建字幕文件 - 分别为caption和speech创建
+        caption_subtitle_file = create_caption_subtitle_file(
+            project_dir, comic_data.captions, panel_start_times, panel_durations
+        )
+        if not caption_subtitle_file:
+            raise HTTPException(status_code=500, detail="Failed to create caption subtitle file")
+        
+        speech_subtitle_file = create_speech_subtitle_file(
+            project_dir, comic_data.speeches, panel_start_times, panel_durations
+        )
+        if not speech_subtitle_file:
+            raise HTTPException(status_code=500, detail="Failed to create speech subtitle file")
+        
+        logger.info(f"Created subtitle files: {caption_subtitle_file}, {speech_subtitle_file}")
+        
         # 创建视频
         output_video = os.path.join(project_dir, "output.mp4")
-        result = create_video(project_dir, image_paths, subtitle_file, audio_file, output_video)
+        result = create_video(
+            project_dir, image_paths, caption_subtitle_file, speech_subtitle_file, 
+            audio_file, output_video, audio_durations, panel_start_times, panel_durations
+        )
         if not result:
             raise HTTPException(status_code=500, detail="Failed to create video")
         
-        # 创建WebDAV目录结构
-        webdav_base_path = f"comic_videos/{project_id}"
+        logger.info(f"Created video: {output_video}")
         
-        # 上传所有资源到WebDAV
-        video_url = upload_to_webdav(output_video, f"{webdav_base_path}/video.mp4")
-        subtitle_url = upload_to_webdav(subtitle_file, f"{webdav_base_path}/subtitles.srt")
-        audio_url = upload_to_webdav(audio_file, f"{webdav_base_path}/audio.mp3")
+        # 上传视频
+        video_url = upload_to_local_storage(output_video, f"{project_id}/video.mp4")
+#        subtitle_url = upload_to_local_storage(subtitle_file, f"{project_id}/captions.srt")
+#        audio_url = upload_to_local_storage(audio_file, f"{project_id}/combined_audio.mp3")
         
         # 上传图片
-        image_urls = []
-        for i, img_path in enumerate(image_paths):
-            remote_path = f"{webdav_base_path}/images/panel_{i}.jpg"
-            img_url = upload_to_webdav(img_path, remote_path)
-            if img_url:
-                image_urls.append(img_url)
+#        image_urls = []
+#        for i, img_path in enumerate(image_paths):
+#            remote_path = f"{project_id}/images/panel_{i}.jpg"
+#            img_url = upload_to_local_storage(img_path, remote_path)
+#            if img_url:
+#                image_urls.append(img_url)
         
         # 后台任务清理临时文件
         background_tasks.add_task(lambda: shutil.rmtree(project_dir, ignore_errors=True))
         
         return {
             "videoUrl": video_url,
-            "subtitleUrl": subtitle_url,
-            "audioUrl": audio_url,
-            "imageUrls": image_urls,
+#            "subtitleUrl": subtitle_url,
+#            "audioUrl": audio_url,
+#            "imageUrls": image_urls,
             "projectId": project_id
         }
     except Exception as e:
         # 清理临时文件
         shutil.rmtree(project_dir, ignore_errors=True)
         logger.error(f"Error generating video: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
         raise HTTPException(status_code=500, detail=str(e))
 
-# 健康检查端点health
+# 健康检查端点
 @app.get("/")
 async def health_check():
     return {"status": "ok"}

requirements.txt

@@ -3,5 +3,4 @@ uvicorn>=0.21.1
 aiohttp>=3.8.4
 openai>=1.2.0
 python-multipart>=0.0.6
-webdavclient3>=3.14.6
 pydantic>=1.10.7