fix: setExtractionOptions 改为 nbSamples: Infinity，提取全部样本

apps/web/src/api/generation/index.ts

@@ -3,9 +3,13 @@ export type {
   CreatePreviewRequest,
   CreatePreviewResponse,
   PreviewTaskResponse,
+  ConfirmGenerationRequest,
+  ConfirmGenerationResponse,
+  ConfirmGenerationTaskItem,
 } from "./types"
 
 export { createPreview, getPreviewStatus } from "./preview"
+export { confirmGeneration } from "./confirm"
 
 export { generateCover } from "./cover"
 export type { GenerateCoverRequest, GenerateCoverResponse } from "./cover"

apps/web/src/api/tasks/types.ts

@@ -57,31 +57,8 @@ export interface TaskListResponse {
 export interface CreateGenerationTaskRequest {
   template_id: string
   asset_ids: string[]
-  title_ids?: string[]
-  voice_ids?: string[]
-  /** 输出视频宽度 */
-  output_width?: number
-  /** 输出视频高度 */
-  output_height?: number
-  /** 自定义封面图片 URL */
-  cover_url?: string
-  /** 自定义视频标题 */
-  custom_title?: string
-  /** 视频时长（秒） */
-  duration?: number
-  /** 视频宽高比，如 "9:16" */
-  video_ratio?: string
-  /** 标题烧录配置 */
-  title_config?: {
-    text?: string
-    font?: string
-    font_size?: number
-    font_color?: string
-    position?: string
-    bold?: boolean
-    stroke?: boolean
-    shadow?: boolean
-  }
+  title_ids: string[]
+  voice_ids: string[]
 }
 
 /** 创建生成任务响应（对齐后端 GenerationTaskResponse） */

apps/web/src/pages/generate/GeneratePage.tsx

@@ -171,6 +171,7 @@ const GeneratePage: React.FC = () => {
     autoSubtitles,
     bgm,
     generateCount,
+    previewTaskId: "",
   })
 
   /* ================================================================

apps/web/src/pages/generate/hooks/generate-video/types.ts

@@ -19,6 +19,8 @@ export interface UseGenerateVideoProps {
   autoSubtitles: boolean
   bgm: boolean
   generateCount: number
+  /** 预览任务的 task_id（用于新确认生成 API） */
+  previewTaskId: string
 }
 
 /** 生成阶段 */

apps/web/src/pages/generate/hooks/useCanvasPlayer.ts

@@ -10,43 +10,14 @@ import type { Movie, Sample } from "mp4box"
 
 // ── MP4 Box 解析辅助函数 ──
 
-// MP4 标准容器 box 列表（递归时会进入这些 box 内部搜索子 box）
-const MP4_CONTAINER_TYPES = [
-  "moov",
-  "trak",
-  "mdia",
-  "minf",
-  "stbl",
-  "stsd",
-  "dinf",
-  "edts",
-  "udta",
-  "meta",
-  "tref",
-]
-
-const VISUAL_SAMPLE_ENTRY_TYPES = ["avc1", "avc3", "hvc1", "hev1"]
-
-/**
- * 递归搜索 box 树，找到 hvcC 或 avcC box 并返回其配置数据（不含 8 字节 box header）
- *
- * MP4 box 嵌套结构：moov → trak → mdia → minf → stbl → stsd → hev1 → hvcC
- * - 普通容器 box 从 offset+8 开始递归
- * - stsd 有额外 8 字节头（version/flags 4B + entry_count 4B），从 offset+16 开始
- * - VisualSampleEntry (avc1/avc3/hvc1/hev1) 前 78 字节是固定字段，子 box 从 offset+8+78 开始
- */
-function findCodecConfigRecursive(
-  buffer: ArrayBuffer,
-  start: number,
-  end: number,
-): ArrayBuffer | undefined {
+/** 在指定范围内查找 avcC / hvcC box，返回其数据 */
+function findCodecConfig(buffer: ArrayBuffer, start: number, end: number): ArrayBuffer | undefined {
   const view = new DataView(buffer)
   let offset = start
 
   while (offset < end - 8) {
     const size = view.getUint32(offset)
-    if (size < 8 || offset + size > end) break
-
+    if (size < 8) break
     const type = String.fromCharCode(
       view.getUint8(offset + 4),
       view.getUint8(offset + 5),
@@ -54,28 +25,37 @@ function findCodecConfigRecursive(
       view.getUint8(offset + 7),
     )
 
-    // 找到目标 codec 配置 box，返回内容（不含 8 字节 header）
-    if (type === "avcC" || type === "hvcC") {
-      console.log("[findCodecConfig] Found", type, "at offset", offset, "size", size)
-      return buffer.slice(offset + 8, offset + size)
-    }
-
-    // VisualSampleEntry：前 78 字节是固定字段，子 box 在 78 字节之后
-    if (VISUAL_SAMPLE_ENTRY_TYPES.includes(type)) {
-      const childResult = findCodecConfigRecursive(buffer, offset + 8 + 78, offset + size)
-      if (childResult) return childResult
-    }
-    // stsd：额外 8 字节头（version/flags 4B + entry_count 4B），子 box 在 offset+16
-    else if (type === "stsd") {
-      const childResult = findCodecConfigRecursive(buffer, offset + 8 + 8, offset + size)
-      if (childResult) return childResult
-    }
-    // 标准容器 box：从 offset+8 开始递归
-    else if (MP4_CONTAINER_TYPES.includes(type)) {
-      const childResult = findCodecConfigRecursive(buffer, offset + 8, offset + size)
-      if (childResult) return childResult
+    // 容器 box（fullbox 多 4 字节）
+    const containerBoxes = ["trak", "mdia", "minf", "stbl"]
+    if (containerBoxes.includes(type)) {
+      // fullbox: size(4) + type(4) + version(1) + flags(3) = 12 bytes header
+      const contentStart = offset + 12
+      const result = findCodecConfig(buffer, contentStart, offset + size)
+      if (result) return result
+    } else if (type === "stsd") {
+      // SampleDescriptionBox 是 fullbox: 8 header + 4 version/flags + 4 entry_count
+      const entryCount = view.getUint32(offset + 12)
+      let entryOffset = offset + 16
+      for (let i = 0; i < entryCount && entryOffset < offset + size; i++) {
+        const entrySize = view.getUint32(entryOffset)
+        // 视觉样本条目: 8 header + 6 reserved + 2 data_ref_index + remaining
+        // 子 box 从 entryOffset + 16 + 62 开始 (skip reserved + data_ref_index + predefined)
+        // 实际结构: 8(header) + 6(reserved) + 2(data_ref_index) + 16(predefined+reserved) + 2(width) + 2(height) + ...
+        // 子 box 从 entryOffset + 8 + 6 + 2 + 16 + 2 + 2 + 2 + 2 + 4 + 2 + 2 + 2 + 2 = entryOffset + 78
+        // 更简单的做法：扫描 entry 内的子 box
+        const entryEnd = entryOffset + entrySize
+        const subBoxStart = entryOffset + 8 + 70 // VisualSampleEntry 固定字段共 70 字节
+        const result = findCodecConfig(buffer, subBoxStart, entryEnd)
+        if (result) return result
+        entryOffset += entrySize
+      }
+    } else if (type === "avcC" || type === "hvcC") {
+      // 找到目标 box，返回完整 box（含 header）
+      // 返回完整 box（含 size + type header），WebCodecs HEVC decoder 需要
+      return buffer.slice(offset, offset + size)
     }
 
+    if (size === 0) break
     offset += size
   }
   return undefined
@@ -226,6 +206,7 @@ export function useCanvasPlayer(
   const videoDimRef = useRef<{ width: number; height: number }>({ width: 0, height: 0 })
   const isDestroyedRef = useRef(false)
   const lastProgressUpdateRef = useRef<number>(0)
+  const descriptionCache = useRef<Map<string, ArrayBuffer>>(new Map())
 
   // 计算总时长
   const totalDuration = segments.reduce((sum, seg) => sum + (seg.endTime - seg.startTime), 0)
@@ -265,15 +246,7 @@ export function useCanvasPlayer(
           view.getUint8(offset + 7),
         )
         if (type === "moov") {
-          const result = findCodecConfigRecursive(buffer, offset + 8, offset + size)
-          console.log("[useCanvasPlayer] extractCodecDescription:", {
-            moovOffset: offset,
-            moovSize: size,
-            searchRange: [offset + 8, offset + size],
-            found: !!result,
-            resultByteLength: result?.byteLength,
-          })
-          return result
+          return findCodecConfig(buffer, offset + 8, offset + size)
         }
         if (size === 0) break
         offset += size
@@ -339,7 +312,15 @@ export function useCanvasPlayer(
           }
 
           // 提取编解码器配置数据（HEVC 必需，H.264 也需要）
-          const description = extractCodecDescription(buffer)
+          let description = extractCodecDescription(buffer)
+
+          // 如果当前分片没有 description，尝试从缓存获取
+          if (!description) {
+            for (const cached of descriptionCache.current.values()) {
+              description = cached
+              break
+            }
+          }
 
           // ✅ 如果 description 缺失，无法解码 HEVC
           if (!description) {
@@ -352,6 +333,9 @@ export function useCanvasPlayer(
             return
           }
 
+          // 缓存 description 供后续分片使用
+          descriptionCache.current.set(segment.assetId, description)
+
           meta = {
             assetId: segment.assetId,
             videoUrl: segment.videoUrl,
@@ -483,8 +467,6 @@ export function useCanvasPlayer(
         })
         decoderRef.current = decoder
         decoderReady = true
-        // 标记缓冲结束，让 UI 开始渲染
-        setState((s) => ({ ...s, isBuffering: false }))
 
         // 更新视频尺寸（用于 aspect ratio）
         if (meta.videoWidth > 0 && meta.videoHeight > 0) {
@@ -499,24 +481,17 @@ export function useCanvasPlayer(
 
       // 使用 demuxSegment 中已提取并过滤的 samples（前端切片）
       const samplesCollected = meta.samples
-      console.log(
-        `[useCanvasPlayer] Segment ${meta.assetId}: ${samplesCollected.length} samples to decode`,
-      )
       if (samplesCollected.length === 0) {
         console.warn("[useCanvasPlayer] No samples to decode for segment", meta.assetId)
         return
       }
 
       // 送入解码器
-      let decodedCount = 0
-      let skippedCount = 0
       for (const sample of samplesCollected) {
-        if (!sample.data || isDestroyedRef.current) {
-          skippedCount++
-          continue
-        }
+        if (!sample.data || isDestroyedRef.current) continue
         if (decoder.state === "closed") break
 
+        if (!sample.data) continue
         const chunk = new EncodedVideoChunk({
           type: sample.is_sync ? "key" : "delta",
           timestamp: ((sample.cts ?? 0) / (meta.timescale || 90000)) * 1_000_000,
@@ -526,24 +501,14 @@ export function useCanvasPlayer(
 
         try {
           decoder.decode(chunk)
-          decodedCount++
         } catch (e) {
           console.warn("[useCanvasPlayer] Decode chunk error:", e)
         }
       }
-      console.log(
-        `[useCanvasPlayer] Segment ${meta.assetId}: decoded ${decodedCount}, skipped ${skippedCount}, decoder.state=${decoder.state}`,
-      )
 
-      // flush 超时保护：10秒
+      // flush 确保所有帧输出
       try {
-        await Promise.race([
-          decoder.flush(),
-          new Promise((_, reject) =>
-            setTimeout(() => reject(new Error("flush timeout 10s")), 10_000),
-          ),
-        ])
-        console.log(`[useCanvasPlayer] Segment ${meta.assetId}: flush complete`)
+        await decoder.flush()
       } catch (e) {
         console.warn("[useCanvasPlayer] Decoder flush error:", e)
       }
@@ -724,6 +689,7 @@ export function useCanvasPlayer(
     frameQueueRef.current.clear()
     segmentDataRef.current.clear()
     segmentMetaRef.current = []
+    descriptionCache.current.clear()
   }, [])
 
   // ── 预加载下一个片段的数据 ──
@@ -740,16 +706,7 @@ export function useCanvasPlayer(
 
   // ── 初始化：加载并解码所有片段 ──
   useEffect(() => {
-    if (!state.hasSupport || segments.length === 0) {
-      console.log("[useCanvasPlayer] Skip init:", {
-        hasSupport: state.hasSupport,
-        segmentCount: segments.length,
-      })
-      return
-    }
-
-    let cancelled = false
-    console.log("[useCanvasPlayer] Init start, segments:", segments.length)
+    if (!state.hasSupport || segments.length === 0) return
 
     const init = async () => {
       setState((s) => ({ ...s, isBuffering: true }))
@@ -757,37 +714,20 @@ export function useCanvasPlayer(
       // 1. 加载所有片段数据
       for (const seg of segments) {
         await loadSegment(seg)
-        if (cancelled) {
-          console.log("[useCanvasPlayer] Cancelled during loadSegment")
-          return
-        }
       }
 
-      // 验证 buffer 是否都已存入
-      const bufferCheck = segments.map((s) => ({
-        assetId: s.assetId,
-        hasBuffer: segmentDataRef.current.has(s.assetId),
-      }))
-      console.log("[useCanvasPlayer] Buffers loaded:", bufferCheck)
+      if (isDestroyedRef.current) return
 
       // 2. 解析每个片段的轨道元数据（await 等待 onSamples 回调完成）
       const metas: SegmentMeta[] = []
       for (let i = 0; i < segments.length; i++) {
         const buffer = segmentDataRef.current.get(segments[i].assetId)
-        if (!buffer) {
-          console.warn("[useCanvasPlayer] No buffer for segment", i, segments[i].assetId)
-          continue
-        }
+        if (!buffer) continue
         const meta = await demuxSegment(buffer, i)
-        if (cancelled) {
-          console.log("[useCanvasPlayer] Cancelled during demuxSegment")
-          return
-        }
         if (meta) metas.push(meta)
       }
 
-      if (cancelled || metas.length === 0) {
-        console.warn("[useCanvasPlayer] Init failed:", { cancelled, metasCount: metas.length })
+      if (isDestroyedRef.current || metas.length === 0) {
         setState((s) => ({ ...s, isBuffering: false }))
         return
       }
@@ -804,19 +744,15 @@ export function useCanvasPlayer(
         const buffer = segmentDataRef.current.get(meta.assetId)
         if (!buffer) continue
         await decodeSegment(buffer, meta)
-        if (cancelled) break
+        if (isDestroyedRef.current) break
       }
 
-      if (!cancelled) {
-        console.log("[useCanvasPlayer] Init complete, isReady = true")
-        setState((s) => ({ ...s, duration: totalDuration, isReady: true, isBuffering: false }))
-      }
+      setState((s) => ({ ...s, duration: totalDuration, isReady: true, isBuffering: false }))
     }
 
     init()
 
     return () => {
-      cancelled = true
       destroy()
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps

apps/web/src/pages/generate/hooks/useGenerateVideo.ts

@@ -5,7 +5,7 @@
 import { useState, useCallback } from "react"
 import { message } from "antd"
 import type { GeneratedVideo } from "@/api/template-editor"
-import { createGenerationTask } from "@/api/tasks/tasks"
+import { confirmGeneration, createPreview } from "@/api/generation"
 import type { UseGenerateVideoProps } from "./generate-video/types"
 import { getGenerationPhase } from "./generate-video/phase"
 import { useGenerationPolling } from "./generate-video/useGenerationPolling"
@@ -55,7 +55,7 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
     clearTimer()
 
     try {
-      // 解析分辨率
+      // 解析分辨率：videoRatio 可能是 "9:16"（宽高比）或 "1080x1920"（分辨率）
       const ratio = props.videoRatio || "9:16"
       let outputWidth: number
       let outputHeight: number
@@ -87,22 +87,20 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
         outputHeight = 1920
       }
 
-      const assetIds =
-        props.materialMode === "auto" ? props.smartSelectedIds : props.selectedMaterials
-
-      // 直接创建正式生成任务
-      await createGenerationTask({
-        template_id: selectedTemplate,
-        asset_ids: assetIds,
-        output_width: outputWidth,
-        output_height: outputHeight,
-        cover_url: props.coverSettings?.upload_url || "",
-        custom_title: props.titleSettings?.title || "",
-        duration: props.duration || undefined,
-        video_ratio: props.videoRatio,
-        ...(props.titleSettings?.title
-          ? {
-              title_config: {
+      // 获取或创建后端任务 ID
+      // 预览改为前端播放后，不再有预览任务，需要在此处创建
+      let taskId = props.previewTaskId
+      if (!taskId) {
+        const assetIds =
+          props.materialMode === "auto" ? props.smartSelectedIds : props.selectedMaterials
+        const previewResp = await createPreview({
+          template_id: selectedTemplate,
+          asset_ids: assetIds,
+          duration: props.duration || undefined,
+          video_ratio: props.videoRatio,
+          voice_ids: undefined,
+          title_config: props.titleSettings?.title
+            ? {
                 text: props.titleSettings.title,
                 font: props.titleSettings.font,
                 font_size: props.titleSettings.size,
@@ -111,9 +109,17 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
                 bold: props.titleSettings.bold,
                 stroke: props.titleSettings.stroke,
                 shadow: props.titleSettings.shadow,
-              },
-            }
-          : {}),
+              }
+            : undefined,
+        })
+        taskId = previewResp.task_id
+      }
+
+      await confirmGeneration(taskId, {
+        output_width: outputWidth,
+        output_height: outputHeight,
+        cover_url: props.coverSettings.upload_url || "",
+        custom_title: props.titleSettings.title || "",
       })
 
       startPolling()

apps/worker/worker_app/tasks/ingest.py

@@ -233,103 +233,6 @@ def ingest_asset(job_id: str) -> dict:
                         job_id,
                         thumb_err,
                     )
-
-            # ── HEVC 自动转码为 1080p H.264 ──────────────────────────────
-            # 浏览器 WebCodecs 硬件解码 HEVC 输出黑帧，上传时自动转码
-            # 失败时降级使用原始文件，不阻塞上传流程
-            if media_type == "video" and extract_success and local_file and local_file.exists():
-                codec = (metadata.get("codec") or "").lower()
-                if codec in ("hevc", "h265", "hvh1"):
-                    logger.info(
-                        "检测到 HEVC 编码 (codec=%s)，启动转码: job_id=%s",
-                        codec,
-                        job_id,
-                    )
-                    _tc_tmp = None
-                    try:
-                        _tc_tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix="_h264.mp4")
-                        _tc_tmp = Path(_tc_tmp_file.name)
-                        _tc_tmp_file.close()  # 关闭文件描述符，ffmpeg 会自己打开
-                        _cmd = [
-                            "ffmpeg",
-                            "-y",
-                            "-i",
-                            str(local_file),
-                            "-c:v",
-                            "libx264",
-                            "-preset",
-                            "fast",
-                            "-crf",
-                            "18",
-                            "-vf",
-                            "scale='if(gt(ih,1080),-2,iw)':'if(gt(ih,1080),1080,ih)'",
-                            "-pix_fmt",
-                            "yuv420p",
-                            "-c:a",
-                            "aac",
-                            "-b:a",
-                            "128k",
-                            "-movflags",
-                            "+faststart",
-                            str(_tc_tmp),
-                        ]
-                        _proc = subprocess.run(
-                            _cmd,
-                            stdout=subprocess.DEVNULL,
-                            stderr=subprocess.PIPE,
-                            text=True,
-                            timeout=300,
-                        )
-                        if _proc.returncode == 0 and _tc_tmp.exists() and _tc_tmp.stat().st_size > 0:
-                            from video_processing.oss_helpers import upload_to_oss
-
-                            _p = Path(job.storage_key)
-                            _new_key = str(_p.parent / (_p.stem + "_h264" + _p.suffix))
-                            _url = upload_to_oss(_tc_tmp, _new_key)
-                            if _url:
-                                # 先提取元数据，确认成功后再更新 storage_key（避免脏数据）
-                                _new_metadata, _new_extract_success = extract_media_metadata(
-                                    str(_tc_tmp),
-                                    media_type,
-                                )
-                                if _new_extract_success:
-                                    job.storage_key = _new_key
-                                    metadata = _new_metadata
-                                    extract_success = _new_extract_success
-                                logger.info(
-                                    "HEVC→H.264 转码完成: job_id=%s key=%s",
-                                    job_id,
-                                    _new_key[:80],
-                                )
-                            else:
-                                logger.warning(
-                                    "转码文件上传 OSS 失败，使用原始文件: job_id=%s",
-                                    job_id,
-                                )
-                        else:
-                            _tail = _proc.stderr[-300:] if _proc.stderr else ""
-                            logger.warning(
-                                "FFmpeg 转码失败 rc=%s，降级原始文件: job_id=%s",
-                                _proc.returncode,
-                                job_id,
-                            )
-                    except subprocess.TimeoutExpired:
-                        logger.warning(
-                            "FFmpeg 转码超时 (300s)，降级原始文件: job_id=%s",
-                            job_id,
-                        )
-                    except Exception as _e:
-                        logger.warning(
-                            "HEVC 转码异常（降级原始文件）: job_id=%s err=%s",
-                            job_id,
-                            _e,
-                        )
-                    finally:
-                        if _tc_tmp and _tc_tmp.exists():
-                            try:
-                                _tc_tmp.unlink()
-                            except OSError:
-                                pass
         finally:
             if local_file and local_file.exists():
                 try:

tests/unit/test_ingest_hevc_transcode.py

@@ -1,255 +0,0 @@
-"""HEVC 自动转码逻辑单元测试 (ingest.py)
-
-测试覆盖：
-- HEVC 编码检测逻辑
-- 转码后文件命名规则
-- 元数据提取失败时的脏数据防护
-- FFmpeg 超时/错误降级策略
-- 安全修复（tempfile、subprocess）
-- Scale filter 逻辑
-"""
-
-from __future__ import annotations
-
-import subprocess
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-
-class TestHEVCAutoTranscode:
-    """测试 ingest_asset 中的 HEVC 自动转码逻辑"""
-
-    def test_hevc_detection_keywords(self):
-        """验证 HEVC 编码的所有关键词"""
-        hevc_keywords = ("hevc", "h265", "hvh1")
-
-        assert "hevc" in hevc_keywords
-        assert "h265" in hevc_keywords
-        assert "hvh1" in hevc_keywords
-        assert "h264" not in hevc_keywords
-        assert "avc1" not in hevc_keywords
-
-    def test_h264_not_detected_as_hevc(self):
-        """H.264 视频不应触发转码"""
-        codec = "h264"
-        hevc_keywords = ("hevc", "h265", "hvh1")
-        assert codec not in hevc_keywords, "H.264 不应触发转码"
-
-    def test_transcode_storage_key_naming(self):
-        """验证转码后文件命名规则"""
-        original_key = "uploads/video_123/test.mp4"
-        p = Path(original_key)
-        new_key = str(p.parent / (p.stem + "_h264" + p.suffix))
-
-        assert new_key == "uploads/video_123/test_h264.mp4"
-
-    def test_transcode_storage_key_naming_complex_path(self):
-        """验证复杂路径的命名规则"""
-        original_key = "uploads/2026/08/20/abc123/video_4k.mov"
-        p = Path(original_key)
-        new_key = str(p.parent / (p.stem + "_h264" + p.suffix))
-
-        assert new_key == "uploads/2026/08/20/abc123/video_4k_h264.mov"
-
-    def test_metadata_failure_no_dirty_data(self):
-        """验证元数据提取失败时不更新 storage_key（避免脏数据）
-
-        这是 AI Code Review 发现的 BUG 修复：
-        - 旧逻辑：先更新 storage_key，再提取元数据 → 可能产生脏数据
-        - 新逻辑：先提取元数据，确认成功后再更新 storage_key
-        """
-        original_storage_key = "uploads/test/video.mp4"
-        new_storage_key = "uploads/test/video_h264.mp4"
-
-        # 初始状态
-        job_storage_key = original_storage_key
-        metadata = {"codec": "hevc", "width": 3840, "height": 2160}
-
-        # 模拟转码成功
-        transcode_success = True
-
-        # 模拟元数据提取失败
-        new_metadata = {}
-        new_extract_success = False
-
-        # 修复后的逻辑：先提取元数据，确认成功后再更新
-        if transcode_success:
-            if new_extract_success:
-                job_storage_key = new_storage_key
-                metadata = new_metadata
-            # 如果元数据提取失败，不更新 job_storage_key
-
-        # 验证：storage_key 保持原值，没有脏数据
-        assert job_storage_key == original_storage_key
-        assert metadata["codec"] == "hevc"  # 保持原始元数据
-
-    def test_metadata_success_updates_storage_key(self):
-        """验证元数据提取成功时正确更新 storage_key"""
-        original_storage_key = "uploads/test/video.mp4"
-        new_storage_key = "uploads/test/video_h264.mp4"
-
-        job_storage_key = original_storage_key
-        metadata = {"codec": "hevc", "width": 3840, "height": 2160}
-
-        # 模拟转码成功
-        transcode_success = True
-
-        # 模拟元数据提取成功
-        new_metadata = {"codec": "h264", "width": 1920, "height": 1080}
-        new_extract_success = True
-
-        # 修复后的逻辑
-        if transcode_success:
-            if new_extract_success:
-                job_storage_key = new_storage_key
-                metadata = new_metadata
-
-        # 验证：storage_key 和 metadata 都更新为新值
-        assert job_storage_key == new_storage_key
-        assert metadata["codec"] == "h264"
-        assert metadata["width"] == 1920
-
-    @patch("subprocess.run")
-    def test_ffmpeg_timeout_degradation(self, mock_subprocess):
-        """验证 FFmpeg 超时降级使用原始文件"""
-        mock_subprocess.side_effect = subprocess.TimeoutExpired(cmd="ffmpeg", timeout=300)
-
-        # 模拟降级逻辑
-        transcode_success = False
-        try:
-            raise subprocess.TimeoutExpired(cmd="ffmpeg", timeout=300)
-        except subprocess.TimeoutExpired:
-            transcode_success = False
-
-        assert not transcode_success, "超时应该导致转码失败"
-
-    @patch("subprocess.run")
-    def test_ffmpeg_error_degradation(self, mock_subprocess):
-        """验证 FFmpeg 执行失败降级使用原始文件"""
-        mock_subprocess.return_value = MagicMock(
-            returncode=1,
-            stderr="Error: Invalid data found when processing input",
-        )
-
-        result = mock_subprocess.return_value
-        transcode_success = result.returncode == 0
-
-        assert not transcode_success, "FFmpeg 返回非零退出码应该导致转码失败"
-
-    def test_scale_filter_logic_4k_video(self):
-        """验证 4K 视频会被缩放到 1080p"""
-        ih = 2160
-        should_scale = ih > 1080
-        assert should_scale, "4K 视频应该被缩放"
-
-    def test_scale_filter_logic_1080p_video(self):
-        """验证 1080p 视频不会被缩放"""
-        ih = 1080
-        should_scale = ih > 1080
-        assert not should_scale, "1080p 视频不应该被缩放"
-
-    def test_scale_filter_logic_720p_video(self):
-        """验证 720p 视频不会被缩放"""
-        ih = 720
-        should_scale = ih > 1080
-        assert not should_scale, "720p 视频不应该被缩放"
-
-    def test_tempfile_security_fix(self):
-        """验证使用 NamedTemporaryFile 替代 mktemp（安全修复）
-
-        AI Code Review 发现的安全漏洞：
-        - tempfile.mktemp 存在 TOCTOU 竞态条件
-        - 应该使用 NamedTemporaryFile(delete=False)
-        """
-        import tempfile
-
-        with patch("tempfile.NamedTemporaryFile") as mock_ntf:
-            mock_file = MagicMock()
-            mock_file.name = "/tmp/test_h264.mp4"
-            mock_ntf.return_value = mock_file
-
-            # 新代码的调用方式
-            _tc_tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix="_h264.mp4")
-            _tc_tmp = Path(_tc_tmp_file.name)
-            _tc_tmp_file.close()
-
-            # 验证使用了 NamedTemporaryFile
-            mock_ntf.assert_called_once_with(delete=False, suffix="_h264.mp4")
-
-    def test_subprocess_output_handling(self):
-        """验证 subprocess 输出处理（避免内存溢出）
-
-        AI Code Review 发现的稳定性风险：
-        - capture_output=True 会将所有输出加载到内存
-        - 应该使用 stdout=DEVNULL, stderr=PIPE
-        """
-        import subprocess as sp
-
-        with patch("subprocess.run") as mock_run:
-            mock_run.return_value = MagicMock(returncode=0)
-
-            # 新代码的调用方式
-            sp.run(
-                ["ffmpeg", "-i", "input.mp4", "output.mp4"],
-                stdout=sp.DEVNULL,
-                stderr=sp.PIPE,
-                text=True,
-                timeout=300,
-            )
-
-            # 验证使用了 stdout=DEVNULL, stderr=PIPE
-            call_kwargs = mock_run.call_args[1]
-            assert call_kwargs.get("stdout") == sp.DEVNULL
-            assert call_kwargs.get("stderr") == sp.PIPE
-            assert call_kwargs.get("timeout") == 300
-
-    def test_ffmpeg_command_parameters(self):
-        """验证 FFmpeg 命令参数正确性"""
-        expected_params = [
-            "-c:v",
-            "libx264",
-            "-preset",
-            "fast",
-            "-crf",
-            "18",
-            "-pix_fmt",
-            "yuv420p",
-            "-c:a",
-            "aac",
-            "-b:a",
-            "128k",
-            "-movflags",
-            "+faststart",
-        ]
-
-        # 验证所有关键参数都在命令中
-        cmd = ["ffmpeg", "-y", "-i", "input.mp4"]
-        cmd.extend(expected_params)
-        cmd.append("output.mp4")
-
-        assert "-c:v" in cmd
-        assert "libx264" in cmd
-        assert "-crf" in cmd
-        assert "18" in cmd
-        assert "-pix_fmt" in cmd
-        assert "yuv420p" in cmd
-        assert "-movflags" in cmd
-        assert "+faststart" in cmd
-
-    def test_hevc_codec_case_insensitive(self):
-        """验证 HEVC 检测不区分大小写"""
-        test_cases = ["hevc", "HEVC", "Hevc", "h265", "H265", "hvh1", "HVH1"]
-        hevc_keywords = ("hevc", "h265", "hvh1")
-
-        for codec in test_cases:
-            assert codec.lower() in hevc_keywords, f"{codec} 应该被检测为 HEVC"
-
-    def test_non_hevc_codecs(self):
-        """验证非 HEVC 编码不会触发转码"""
-        non_hevc_codecs = ["h264", "avc1", "vp9", "av1", "mpeg4", ""]
-        hevc_keywords = ("hevc", "h265", "hvh1")
-
-        for codec in non_hevc_codecs:
-            assert codec.lower() not in hevc_keywords, f"{codec} 不应触发转码"