Update app.py

app.py

@@ -1,5 +1,5 @@
 from fastapi import FastAPI, File, UploadFile, HTTPException, Form
-from fastapi.responses import FileResponse
+from fastapi.responses import FileResponse, PlainTextResponse
 import tempfile
 import os
 import numpy as np
@@ -12,11 +12,13 @@ from pathlib import Path
 from typing import Optional, List
 import random
 import math
+import traceback
+import sys
 
 app = FastAPI(title="Video Generator with Effects API")
 
 # ============================================================
-# 特效系统
+# 特效系统（和你之前一样，此处省略完整代码）
 # ============================================================
 
 class Particle:
@@ -53,7 +55,6 @@ def draw_snowflake(draw, x, y, size, opacity):
     r = int(size * 3)
     color = (255, 255, 255, int(opacity))
     draw.ellipse([x - r, y - r, x + r, y + r], fill=color)
-    # 十字光芒
     for angle in [0, math.pi / 3, math.pi * 2 / 3]:
         ex = x + math.cos(angle) * r * 1.5
         ey = y + math.sin(angle) * r * 1.5
@@ -64,7 +65,6 @@ def draw_leaf(draw, x, y, size, opacity, rotation):
     leaf_colors = [(180, 60, 30), (200, 120, 20), (220, 160, 40), (160, 80, 20)]
     color = random.choice(leaf_colors) + (int(opacity),)
     r = int(size * 5)
-    # 简单椭圆叶片
     img = Image.new('RGBA', (r * 2, r * 2), (0, 0, 0, 0))
     leaf_draw = ImageDraw.Draw(img)
     leaf_draw.ellipse([r * 0.2, r * 0.5, r * 1.8, r * 1.5], fill=color)
@@ -82,7 +82,6 @@ def draw_sparkle(draw, x, y, size, opacity):
     gold = (255, 215, 0, int(opacity))
     r = int(size * 2)
     draw.ellipse([x - r, y - r, x + r, y + r], fill=gold)
-    # 光芒
     for angle in range(0, 360, 45):
         rad = math.radians(angle)
         ex = x + math.cos(rad) * r * 2
@@ -97,15 +96,14 @@ def draw_dust(draw, x, y, size, opacity):
 
 
 def apply_effect(frame, particles, effect_type):
-    """在单帧上叠加特效"""
     img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA))
     overlay = Image.new('RGBA', img.size, (0, 0, 0, 0))
     draw = ImageDraw.Draw(overlay)
-    draw._image = overlay  # 为了让 draw_leaf 能访问
+    draw._image = overlay
 
     for p in particles:
         p.update()
-        opacity = p.opacity * (1 - (p.y / (p.h + 50)))  # 远处淡一点
+        opacity = p.opacity * (1 - (p.y / (p.h + 50)))
         opacity = max(10, min(255, opacity))
 
         if effect_type == "snow":
@@ -124,41 +122,27 @@ def apply_effect(frame, particles, effect_type):
 
 
 def apply_old_film(frame, frame_idx, fps):
-    """老电影效果：随机划痕+闪烁+褪色"""
     h, w = frame.shape[:2]
-
-    # 随机闪烁
     if random.random() < 0.03:
         flicker = random.uniform(0.6, 1.0)
         frame = (frame * flicker).astype(np.uint8)
-
-    # 随机划痕
     if random.random() < 0.02:
         x = random.randint(0, w - 1)
         length = random.randint(10, h // 3)
         y = random.randint(0, h - length)
         cv2.line(frame, (x, y), (x + random.randint(-2, 2), y + length), (255, 255, 255), 1)
-
-    # 褪色效果
     frame = cv2.addWeighted(frame, 0.85, np.full_like(frame, (200, 180, 150)), 0.15, 0)
-
-    # 暗角
     mask = np.zeros((h, w), dtype=np.float32)
     cv2.ellipse(mask, (w // 2, h // 2), (int(w * 0.7), int(h * 0.7)), 0, 0, 360, 1, -1)
     mask = cv2.GaussianBlur(mask, (0, 0), w // 3)
     mask = mask.reshape(h, w, 1)
     frame = (frame * (0.4 + 0.6 * mask)).astype(np.uint8)
-
     return frame
 
 
 def apply_heat_haze(frame, frame_idx, fps):
-    """热气蒸腾效果：局部扭曲"""
     h, w = frame.shape[:2]
-    # 只在底部产生热浪
     y_start = h * 3 // 4
-    region = frame[y_start:, :]
-    # 正弦波位移
     displacement = (np.sin(np.linspace(0, math.pi * 4, w) + frame_idx * 0.3) * 3).astype(np.int32)
     map_x = np.tile(np.arange(w, dtype=np.float32), (h - y_start, 1))
     map_y = np.tile(np.arange(y_start, h, dtype=np.float32).reshape(-1, 1), (1, w))
@@ -170,24 +154,17 @@ def apply_heat_haze(frame, frame_idx, fps):
 
 
 def apply_flame(frame, frame_idx, fps):
-    """火焰效果：画面底部橙色渐变+闪烁"""
     h, w = frame.shape[:2]
     flame_h = h // 5
     flame = np.zeros((flame_h, w, 3), dtype=np.uint8)
-
     for i in range(flame_h):
         alpha = 1 - (i / flame_h)
-        # 火焰颜色：从橙色到黄色
         r = int(255 * alpha)
         g = int(140 * alpha * (0.5 + 0.5 * math.sin(frame_idx * 0.5 + i * 0.3)))
         b = 0
         flame[i, :] = (b, g, r)
-
-    # 闪烁
     flicker = 0.7 + 0.3 * math.sin(frame_idx * 0.8) * random.uniform(0.8, 1.2)
     flame = (flame * flicker).astype(np.uint8)
-
-    # 合成
     roi = frame[h - flame_h:, :]
     blended = cv2.addWeighted(roi, 0.4, flame, 0.6, 0)
     frame[h - flame_h:, :] = blended
@@ -199,7 +176,6 @@ def apply_flame(frame, frame_idx, fps):
 # ============================================================
 
 def parse_srt(srt_text: str):
-    """解析 SRT 为 [(start_sec, end_sec, text), ...]"""
     segments = []
     blocks = srt_text.strip().split("\n\n")
     for block in blocks:
@@ -220,7 +196,6 @@ def timestamp_to_seconds(ts: str):
 
 
 def get_chinese_font():
-    """尝试获取中文字体"""
     fonts = [
         "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
         "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
@@ -236,7 +211,6 @@ def get_chinese_font():
 
 
 def draw_subtitle(frame, text, font, w, h):
-    """在画面底部绘制字幕"""
     if not text:
         return frame
     img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
@@ -248,7 +222,6 @@ def draw_subtitle(frame, text, font, w, h):
     except:
         font_obj = ImageFont.load_default()
 
-    # 文字换行
     max_width = w * 0.85
     lines = []
     current_line = ""
@@ -263,12 +236,10 @@ def draw_subtitle(frame, text, font, w, h):
     if current_line:
         lines.append(current_line)
 
-    # 计算位置
     line_height = font_size + 8
     total_height = len(lines) * line_height
     y_start = h - total_height - 60
 
-    # 半透明背景
     for i, line in enumerate(lines):
         bbox = draw.textbbox((0, 0), line, font=font_obj)
         text_w = bbox[2] - bbox[0]
@@ -298,48 +269,54 @@ def generate_video(
 ):
     # 解析字幕
     subtitle_segments = parse_srt(srt_text)
+    print(f"📝 解析到 {len(subtitle_segments)} 条字幕", file=sys.stderr)
 
     # 获取音频时长
     audio = AudioSegment.from_file(audio_path)
-    total_duration = len(audio) / 1000.0  # 秒
+    total_duration = len(audio) / 1000.0
     total_frames = int(total_duration * fps)
+    print(f"🎵 音频时长: {total_duration:.1f}秒, 总帧数: {total_frames}", file=sys.stderr)
 
     # 加载图片
     images = [cv2.imread(p) for p in image_paths]
     images = [img for img in images if img is not None]
     if not images:
-        raise ValueError("No valid images found")
+        raise ValueError("没有有效的图片文件")
+    print(f"🖼️ 加载了 {len(images)} 张图片", file=sys.stderr)
 
-    # 统一图片尺寸
-    h, w = 720, 1280  # 默认 720p 竖屏，可改
+    # 统一尺寸
+    h, w = 720, 1280
     images_resized = []
-    for img in images:
+    for i, img in enumerate(images):
         img = cv2.resize(img, (w, h))
         images_resized.append(img)
+        print(f"   图片{i+1}: {img.shape}", file=sys.stderr)
 
-    # 每张图展示的帧数
     frames_per_image = total_frames // len(images_resized)
 
-    # 初始化特效粒子
+    # 初始化粒子
     particles = []
     if effect in ("snow", "leaves", "rain", "sparkle", "dust"):
         for _ in range(80):
             particles.append(Particle(w, h, effect))
 
-    # 字体
     font_path = get_chinese_font()
+    print(f"🔤 字体: {font_path or '默认'}", file=sys.stderr)
 
     # 视频写入
     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
     temp_video = output_path.replace(".mp4", "_temp.mp4")
     out = cv2.VideoWriter(temp_video, fourcc, fps, (w, h))
 
+    if not out.isOpened():
+        raise RuntimeError(f"无法创建视频文件: {temp_video}")
+
+    print(f"🎬 开始写入视频帧...", file=sys.stderr)
     for frame_idx in range(total_frames):
-        # 选择当前图片
         img_idx = min(frame_idx // frames_per_image, len(images_resized) - 1)
         frame = images_resized[img_idx].copy()
 
-        # 应用特效
+        # 特效
         if effect in ("snow", "leaves", "rain", "sparkle", "dust"):
             frame = apply_effect(frame, particles, effect)
         elif effect == "flame":
@@ -349,44 +326,49 @@ def generate_video(
         elif effect == "heat":
             frame = apply_heat_haze(frame, frame_idx, fps)
 
-        # 当前时间
+        # 字幕
         current_time = frame_idx / fps
-
-        # 查找当前字幕
         current_sub = ""
         for start, end, text in subtitle_segments:
             if start <= current_time <= end:
                 current_sub = text
                 break
-
-        # 绘制字幕
         if current_sub:
             frame = draw_subtitle(frame, current_sub, font_path, w, h)
 
         out.write(frame)
 
+        if frame_idx % (fps * 10) == 0:
+            print(f"   进度: {frame_idx}/{total_frames} 帧 ({100*frame_idx//total_frames}%)", file=sys.stderr)
+
     out.release()
+    print(f"✅ 视频帧写入完成", file=sys.stderr)
 
-    # 音频处理
-    if bgm_path:
+    # 检查临时视频
+    if not os.path.exists(temp_video) or os.path.getsize(temp_video) == 0:
+        raise RuntimeError(f"临时视频文件生成失败: {temp_video}")
+
+    # 音频混音
+    print(f"🔊 处理音频...", file=sys.stderr)
+    if bgm_path and os.path.exists(bgm_path):
         bgm = AudioSegment.from_file(bgm_path)
-        # BGM 循环或截断到人声长度
         if len(bgm) < len(audio):
             loops = len(audio) // len(bgm) + 1
             bgm = bgm * loops
         bgm = bgm[:len(audio)]
-        # BGM 降低音量作为背景
         bgm = bgm - 15
-        # 混合
         mixed_audio = audio.overlay(bgm)
+        print(f"   BGM已混合", file=sys.stderr)
     else:
         mixed_audio = audio
 
     temp_audio = output_path.replace(".mp4", "_temp.wav")
     mixed_audio.export(temp_audio, format="wav")
+    print(f"✅ 音频导出完成", file=sys.stderr)
 
     # FFmpeg 合成
-    subprocess.run([
+    print(f"🎬 FFmpeg 合成中...", file=sys.stderr)
+    result = subprocess.run([
         "ffmpeg", "-y",
         "-i", temp_video,
         "-i", temp_audio,
@@ -395,12 +377,24 @@ def generate_video(
         "-pix_fmt", "yuv420p",
         "-shortest",
         output_path
-    ], check=True, capture_output=True)
+    ], check=False, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        print(f"❌ FFmpeg 错误:\n{result.stderr}", file=sys.stderr)
+        raise RuntimeError(f"FFmpeg 合成失败: {result.stderr[:500]}")
+
+    print(f"✅ FFmpeg 合成完成", file=sys.stderr)
 
-    # 清理
-    os.unlink(temp_video)
-    os.unlink(temp_audio)
+    # 清理临时文件
+    for tmp in [temp_video, temp_audio]:
+        if os.path.exists(tmp):
+            os.unlink(tmp)
 
+    # 最终检查
+    if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
+        raise RuntimeError(f"最终视频文件生成失败: {output_path}")
+
+    print(f"✅ 视频生成成功: {output_path} ({os.path.getsize(output_path)} bytes)", file=sys.stderr)
     return output_path
 
 
@@ -408,7 +402,7 @@ def generate_video(
 # API 路由
 # ============================================================
 
-EFFECTS = ["snow", "leaves", "rain", "sparkle", "dust", "flame", "oldfilm", "heat", "none"]
+EFFECTS = ["snow", "leaves", "rain", "sparkle", "dust", "flame", "heat", "oldfilm", "none"]
 
 
 @app.get("/")
@@ -416,7 +410,8 @@ async def root():
     return {
         "message": "Video Generator with Effects API",
         "endpoints": {
-            "/generate": "POST - Generate video with effects"
+            "/generate": "POST - Generate video with effects",
+            "/health": "GET - Health check"
         },
         "effects": EFFECTS,
         "input": {
@@ -425,7 +420,7 @@ async def root():
             "srt": "SRT subtitle text as string",
             "bgm": "Background music file (optional)",
             "effect": f"One of: {EFFECTS}",
-            "resolution": "720p or 1080p (default 720p)"
+            "resolution": "720p"
         }
     }
 
@@ -442,48 +437,86 @@ async def generate(
     srt_text: str = Form(...),
     bgm: Optional[UploadFile] = File(None),
     effect: str = Form("snow"),
-    resolution: str = Form("720p")
 ):
     if effect not in EFFECTS:
-        raise HTTPException(status_code=400, detail=f"Invalid effect. Choose from: {EFFECTS}")
+        raise HTTPException(status_code=400, detail=f"无效特效。可选: {EFFECTS}")
 
-    # 保存上传文件
     tmp_dir = tempfile.mkdtemp()
+    print(f"📂 临时目录: {tmp_dir}", file=sys.stderr)
+
     try:
         # 保存图片
         image_paths = []
         for i, img in enumerate(images):
             suffix = Path(img.filename).suffix if img.filename else ".jpg"
             path = os.path.join(tmp_dir, f"image_{i}{suffix}")
+            content = await img.read()
             with open(path, "wb") as f:
-                f.write(await img.read())
+                f.write(content)
             image_paths.append(path)
+            print(f"   保存图片{i+1}: {path} ({len(content)} bytes)", file=sys.stderr)
 
         # 保存音频
-        audio_path = os.path.join(tmp_dir, f"audio{Path(audio.filename).suffix or '.wav'}")
+        audio_suffix = Path(audio.filename).suffix if audio.filename else ".wav"
+        audio_path = os.path.join(tmp_dir, f"audio{audio_suffix}")
+        audio_content = await audio.read()
         with open(audio_path, "wb") as f:
-            f.write(await audio.read())
+            f.write(audio_content)
+        print(f"   保存音频: {audio_path} ({len(audio_content)} bytes)", file=sys.stderr)
 
         # 保存 BGM
         bgm_path = None
         if bgm:
-            bgm_path = os.path.join(tmp_dir, f"bgm{Path(bgm.filename).suffix or '.mp3'}")
+            bgm_suffix = Path(bgm.filename).suffix if bgm.filename else ".mp3"
+            bgm_path = os.path.join(tmp_dir, f"bgm{bgm_suffix}")
+            bgm_content = await bgm.read()
             with open(bgm_path, "wb") as f:
-                f.write(await bgm.read())
+                f.write(bgm_content)
+            print(f"   保存BGM: {bgm_path} ({len(bgm_content)} bytes)", file=sys.stderr)
+
+        # 字幕信息
+        srt_preview = srt_text[:100].replace("\n", "\\n")
+        print(f"   字幕: {srt_preview}...", file=sys.stderr)
 
         # 生成视频
         output_path = os.path.join(tmp_dir, "output.mp4")
+        print(f"🚀 开始生成视频 → {output_path}", file=sys.stderr)
+
         generate_video(image_paths, audio_path, srt_text, bgm_path, effect, output_path)
 
-        return FileResponse(output_path, media_type="video/mp4", filename="output.mp4")
+        # 验证文件存在
+        if not os.path.exists(output_path):
+            raise RuntimeError(f"视频生成失败，文件不存在: {output_path}")
+
+        file_size = os.path.getsize(output_path)
+        print(f"✅ 生成成功: {output_path} ({file_size} bytes)", file=sys.stderr)
+
+        # 直接读取文件内容返回，避免 FileResponse 的路径问题
+        with open(output_path, "rb") as f:
+            video_bytes = f.read()
+
+        # 清理
+        import shutil
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+        from fastapi.responses import Response
+        return Response(
+            content=video_bytes,
+            media_type="video/mp4",
+            headers={"Content-Disposition": "attachment; filename=output.mp4"}
+        )
 
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Generation failed: {str(e)}")
-    finally:
+        error_msg = f"生成失败: {str(e)}"
+        print(f"❌ {error_msg}", file=sys.stderr)
+        print(traceback.format_exc(), file=sys.stderr)
+
         # 清理
         import shutil
         shutil.rmtree(tmp_dir, ignore_errors=True)
 
+        raise HTTPException(status_code=500, detail=error_msg)
+
 
 if __name__ == "__main__":
     import uvicorn