Skip to content

利用 AI 大模型和自动化工作流,根据主题或关键词一键生成高清短视频。Generate HD short videos from a topic or keyword with an automated AI workflow.

feat(material): add WaveSpeed video source

C9a739dae307b
diff --git a/README-en.md b/README-en.md
index 39719eca..61cc8d0a 100644
--- a/README-en.md
+++ b/README-en.md
@@ -131,6 +131,7 @@ Thanks to [Kimi](https://platform.kimi.ai?track_id=track-f6b0a640d35c41deb03b247
- [x] Supports **subtitle generation** with configurable fonts, position, color, size, outline, and background styles
- [x] Supports random or custom **background music** with adjustable volume
- [x] Supports your own **local assets** and free-to-use HD footage from **Pexels**, **Pixabay**, and **Coverr**
+- [x] Supports **AI-generated footage**: [WaveSpeed AI](https://wavespeed.ai) text-to-video models (Seedance by default) create brand-new visuals from your script keywords instead of relying on stock libraries
- [x] Supports leading model providers including **Kimi / Moonshot AI**, **OpenAI**, **Google Gemini**, **DeepSeek**, **Alibaba Cloud Qwen**, **Microsoft Azure OpenAI**, **ByteDance VolcEngine Ark**, **xAI Grok**, **MiniMax**, and **Xiaomi MiMo**, plus unified gateways, aggregators, and local runtimes such as **Cloudflare AI Gateway**, **Alibaba ModelScope**, **AIHubMix**, **AIML API**, **EvoLink**, **Ollama**, **OneAPI**, **LiteLLM**, **Groq**, and **Pollinations AI**
- [x] Supports one-click **cross-platform publishing** to **TikTok**, **Instagram**, and **YouTube Shorts** after video generation
- [x] Supports **exporting and importing generation settings** as a preset file, and backing up and restoring every **API key** from the settings dialog
diff --git a/README.md b/README.md
index ce3a3132..1bffc636 100644
--- a/README.md
+++ b/README.md
@@ -141,6 +141,7 @@
- [x] 支持 **字幕生成**,可调整字体、位置、颜色、大小、描边和背景样式
- [x] 支持 **背景音乐**,可随机选择或使用指定音乐,并调整音量
- [x] 支持使用自己的 **本地素材**,也可从 **Pexels**、**Pixabay** 和 **Coverr** 获取可免费使用的高清素材
+- [x] 支持 **AI 生成素材**:接入 [WaveSpeed AI](https://wavespeed.ai) 文生视频模型(默认 Seedance),按脚本关键词直接生成全新画面,不再受限于库存素材
- [x] 支持 **Kimi / Moonshot AI**、**OpenAI**、**Google Gemini**、**DeepSeek**、**阿里云通义千问**、**Microsoft Azure OpenAI**、**火山引擎方舟**、**xAI Grok**、**MiniMax**、**小米 MiMo** 等主流模型服务,并兼容 **Cloudflare AI Gateway**、**魔搭 ModelScope**、**AIHubMix**、**AIML API**、**EvoLink**、**Ollama**、**OneAPI**、**LiteLLM**、**Groq**、**Pollinations AI** 等统一网关、聚合平台和本地运行环境
- [x] 支持一键 **跨平台发布**,生成完成后可自动上传至 **TikTok**、**Instagram** 和 **YouTube Shorts**
- [x] 支持将生成设置**导出和导入**为预设文件,并在设置弹窗中备份和恢复所有 **API Key**
diff --git a/app/services/material.py b/app/services/material.py
index 15b783db..0df26ebb 100644
--- a/app/services/material.py
+++ b/app/services/material.py
@@ -1,6 +1,7 @@
import os
import random
import threading
+import time
from pathlib import Path
from typing import Any, Callable, List
from urllib.parse import quote_plus, urlencode, urlsplit, urlunsplit
@@ -603,6 +604,386 @@ def search_videos_coverr(
return []
+# WaveSpeed AI (https://wavespeed.ai) 通过文生视频模型按脚本关键词直接生成素材,
+# 与三个库存素材源共用 MaterialInfo 结果结构和后续下载、剪辑流程。
+WAVESPEED_API_BASE_URL = "https://api.wavespeed.ai/api/v3"
+WAVESPEED_DEFAULT_T2V_MODEL = "bytedance/seedance-2.0-fast/text-to-video"
+WAVESPEED_POLL_INTERVAL_SECONDS = 2.0
+WAVESPEED_RUN_TIMEOUT_SECONDS = 600.0
+# 默认模型 bytedance/seedance-2.0-fast/text-to-video 只接受 4-15 秒;超出
+# 范围的请求会被 API 直接拒绝。WebUI 默认片段时长是 3 秒,因此必须在提交
+# 前收敛到模型支持区间,多出的时长由现有剪辑流程按片段时长裁掉。
+WAVESPEED_MIN_DURATION_SECONDS = 4
+WAVESPEED_MAX_DURATION_SECONDS = 15
+# 三个失败态语义不同(模型报错 / 用户取消 / 平台超时),但对素材流程都意味着
+# 本关键词没有产物,统一按空结果处理,交给上层跳过该片段继续生成。
+WAVESPEED_FAILURE_STATUSES = frozenset({"failed", "cancelled", "timeout"})
+# 与 WaveSpeed 官方 Python SDK / n8n 节点保持同一口径:429 与 5xx 属于临时
+# 故障,值得有限次退避重试;4xx 是明确的客户端错误,快速失败。
+WAVESPEED_RETRYABLE_STATUS_CODES = frozenset({429, 500, 502, 503, 504})
+# 单次轮询允许的连续临时失败次数。一次不走运的 GET 不能让已经计费的任务失联。
+WAVESPEED_MAX_POLL_RETRIES = 5
+# 线性退避基数,第 n 次重试等待 base * n 秒。
+WAVESPEED_RETRY_BASE_SECONDS = 1.0
+# 产物下载失败时对同一个签名地址的重试次数。素材已经付费生成,优先重试原
+# 地址,不能因为一次下载抖动就重新提交一次付费生成任务。
+WAVESPEED_MAX_DOWNLOAD_RETRIES = 2
+
+
+class WaveSpeedUnconfirmedTaskError(RuntimeError):
+ """
+ 付费生成任务已提交,但最终状态无法在本地确认。
+
+ 这类异常绝不等价于“该任务失败、可以重来”:远端任务可能仍在运行或已经
+ 完成并计费。素材流程必须就此停止,不再为后续关键词提交新的付费任务,
+ 并把已提交的 prediction id 留在日志中供人工找回。
+ """
+
+ def __init__(self, message: str, prediction_id: str = ""):
+ super().__init__(message)
+ self.prediction_id = prediction_id
+
+
+def _wavespeed_status_code(response: Any) -> int:
+ """读取响应状态码;测试替身或异常对象缺少该字段时按 200 处理。"""
+ try:
+ return int(getattr(response, "status_code", 200))
+ except (TypeError, ValueError):
+ return 200
+
+
+def _is_wavespeed_retryable_error(error: Exception) -> bool:
+ """
+ 判断轮询异常是否值得重试。
+
+ 连接、超时一类网络异常没有状态码,按临时故障处理;带状态码的响应只在
+ 429 和 5xx 时重试,与官方 SDK 的重试集合保持一致。
+ """
+ if isinstance(
+ error,
+ (
+ requests.exceptions.ConnectionError,
+ requests.exceptions.Timeout,
+ requests.exceptions.ChunkedEncodingError,
+ ),
+ ):
+ return True
+ response = getattr(error, "response", None)
+ if response is not None:
+ return _wavespeed_status_code(response) in WAVESPEED_RETRYABLE_STATUS_CODES
+ return False
+
+
+def _wavespeed_duration_bounds() -> tuple[int, int]:
+ """
+ 返回当前模型支持的生成时长区间(秒)。
+
+ 默认区间对应默认 Seedance 模型;用户切换到其它文生视频模型时,可以在
+ 配置中同步调整区间。任何异常配置都退回默认值,并保证 min <= max,
+ 避免把用户输入变成必然失败的远端请求。
+ """
+
+ def read_bound(key: str, fallback: int) -> int:
+ try:
+ value = int(config.app.get(key, fallback))
+ except (TypeError, ValueError):
+ return fallback
+ return value if value >= 1 else fallback
+
+ min_duration = read_bound("wavespeed_min_duration", WAVESPEED_MIN_DURATION_SECONDS)
+ max_duration = read_bound("wavespeed_max_duration", WAVESPEED_MAX_DURATION_SECONDS)
+ return min_duration, max(max_duration, min_duration)
+
+
+def generate_videos_wavespeed(
+ search_term: str,
+ minimum_duration: int,
+ video_aspect: VideoAspect = VideoAspect.portrait,
+) -> List[MaterialInfo]:
+ """
+ 用 WaveSpeed 文生视频模型为一个脚本关键词生成一段素材。
+
+ 与库存素材源的 search_videos_* 保持同一签名和空列表失败约定,
+ 使其可以直接接入 ``download_videos`` 的通用下载与时长核算流程。
+ ``minimum_duration`` 在生成语境下就是目标片段时长(秒)。
+ """
+ aspect = VideoAspect(video_aspect)
+ video_width, video_height = aspect.to_resolution()
+ api_key = get_api_key("wavespeed_api_keys")
+ model_id = (
+ str(
+ config.app.get("wavespeed_text_to_video_model", "")
+ or WAVESPEED_DEFAULT_T2V_MODEL
+ )
+ .strip()
+ .strip("/")
+ )
+ headers = {"Authorization": f"Bearer {api_key}"}
+ requested_duration = max(int(minimum_duration), 1)
+ min_duration, max_duration = _wavespeed_duration_bounds()
+ duration = min(max(requested_duration, min_duration), max_duration)
+ if duration != requested_duration:
+ # 生成比请求更长不会影响成片:剪辑流程仍按片段时长裁剪;生成比请求
+ # 更短的情况只发生在请求超过模型上限时,此时也只能收敛到上限。
+ logger.info(
+ f"wavespeed clip duration clamped to model-supported range: "
+ f"requested={requested_duration}s, using={duration}s "
+ f"(supported {min_duration}-{max_duration}s)"
+ )
+ payload = {
+ "prompt": search_term,
+ "aspect_ratio": aspect.value,
+ "duration": duration,
+ }
+ logger.info(
+ f"generating video on wavespeed: model={model_id}, "
+ f"term={search_term!r}, duration={duration}s"
+ )
+
+ # 提交 POST 绝不自动重试:请求可能已经在远端创建了付费任务,重发会造成
+ # 重复生成和重复扣费(与官方 SDK 的 submission 策略一致)。
+ try:
+ submit_response = requests.post(
+ f"{WAVESPEED_API_BASE_URL}/{model_id}",
+ json=payload,
+ headers=headers,
+ proxies=config.proxy,
+ verify=_get_tls_verify(),
+ timeout=(30, 60),
+ )
+ except Exception as e:
+ # 没有收到响应并不代表任务没有创建。此时状态不明,必须终止整个生成
+ # 流程,而不是继续为下一个关键词提交新的付费任务。
+ raise WaveSpeedUnconfirmedTaskError(
+ "wavespeed submission did not return a response, the task may "
+ "already exist remotely: "
+ f"error={type(e).__name__}, detail={_redact_request_error(e, api_key)}"
+ ) from e
+
+ submit_status = _wavespeed_status_code(submit_response)
+ if submit_status >= 500:
+ # 5xx 可能发生在任务创建之后,无法判断是否已经计费。
+ raise WaveSpeedUnconfirmedTaskError(
+ f"wavespeed submission failed with HTTP {submit_status}, "
+ "the task may already exist remotely"
+ )
+ try:
+ submit_body = submit_response.json()
+ except Exception as e:
+ raise WaveSpeedUnconfirmedTaskError(
+ "wavespeed submission returned an unreadable response, the task "
+ f"may already exist remotely: error={type(e).__name__}"
+ ) from e
+
+ submit_data = submit_body.get("data") if isinstance(submit_body, dict) else None
+ if not isinstance(submit_body, dict) or submit_body.get("code") != 200:
+ # 4xx 与业务错误码是明确的拒绝,远端没有创建任务,也就不存在重复
+ # 计费风险,按现有素材源约定返回空结果并继续。
+ logger.error(
+ "wavespeed video generation request rejected: "
+ f"http_status={submit_status}, "
+ f"code={submit_body.get('code') if isinstance(submit_body, dict) else None}, "
+ f"detail={_redact_secret(str((submit_body or {}).get('message') or ''), api_key)}"
+ )
+ return []
+ prediction_id = (
+ str(submit_data.get("id") or "") if isinstance(submit_data, dict) else ""
+ )
+ if not prediction_id:
+ # 提交被接受但没拿到 ID:任务可能已经存在却无法追踪,不能继续下单。
+ raise WaveSpeedUnconfirmedTaskError(
+ "wavespeed accepted the submission without returning a prediction id"
+ )
+ # 生成任务提交成功即产生远端计费副作用,先落日志记录任务 ID,
+ # 即使后续轮询失败,用户仍能凭 ID 在 WaveSpeed 控制台找回产物。
+ logger.info(f"wavespeed prediction created: id={prediction_id}")
+
+ result_data = _wait_for_wavespeed_prediction(
+ prediction_id=prediction_id,
+ headers=headers,
+ api_key=api_key,
+ )
+ if result_data is None:
+ return []
+
+ try:
+ video_items = []
+ outputs = result_data.get("outputs")
+ for output in outputs if isinstance(outputs, list) else []:
+ # 产物 URL 是带签名的临时下载地址,必须整体保留(不能剥离查询参
+ # 数),因此不写入 source_info,只用于随后的立即下载。
+ if not isinstance(output, str) or not output.startswith(
+ ("http://", "https://")
+ ):
+ continue
+ item = MaterialInfo()
+ item.provider = "wavespeed"
+ item.url = output
+ item.duration = duration
+ item.source_info = {
+ "provider": "wavespeed",
+ "search_term": search_term,
+ "asset_id": prediction_id,
+ "rendition": {
+ "id": None,
+ "width": video_width,
+ "height": video_height,
+ },
+ }
+ video_items.append(item)
+ if not video_items:
+ logger.error(
+ "wavespeed prediction completed without downloadable outputs: "
+ f"id={prediction_id}"
+ )
+ return video_items
+ except Exception as e:
+ # 产物已经生成并计费,这里的异常只可能来自本地解析。记录后按空结果
+ # 返回,让上层跳过该片段,但任务状态本身是确定的,可以继续后续片段。
+ logger.error(
+ "wavespeed output parsing failed: "
+ f"id={prediction_id}, error={type(e).__name__}, "
+ f"detail={_redact_request_error(e, api_key)}"
+ )
+
+ return []
+
+
+def _wait_for_wavespeed_prediction(
+ *,
+ prediction_id: str,
+ headers: dict,
+ api_key: str,
+) -> dict | None:
+ """
+ 轮询同一个 prediction id 直到出现确定结果。
+
+ 返回 ``completed`` 的 data;远端明确失败(failed / cancelled / timeout)
+ 时返回 None,表示该任务已经结束、可以安全地继续后续片段。临时故障按
+ 线性退避重试同一个 ID,绝不重新提交任务;状态始终无法确认时抛出
+ :class:`WaveSpeedUnconfirmedTaskError`,由调用方终止整个生成流程。
+ """
+ deadline = time.monotonic() + WAVESPEED_RUN_TIMEOUT_SECONDS
+ consecutive_failures = 0
+ while True:
+ try:
+ response = requests.get(
+ f"{WAVESPEED_API_BASE_URL}/predictions/{prediction_id}/result",
+ headers=headers,
+ proxies=config.proxy,
+ verify=_get_tls_verify(),
+ timeout=(30, 60),
+ )
+ status_code = _wavespeed_status_code(response)
+ if status_code in WAVESPEED_RETRYABLE_STATUS_CODES:
+ raise requests.exceptions.HTTPError(
+ f"HTTP {status_code}", response=response
+ )
+ result_body = response.json()
+ result_data = (
+ result_body.get("data") if isinstance(result_body, dict) else None
+ )
+ if not isinstance(result_body, dict) or result_body.get("code") != 200:
+ # 轮询被明确拒绝(如 4xx)时任务状态仍然未知:任务已经提交,
+ # 只是本地查不到结果,同样不能继续提交新的付费任务。
+ raise WaveSpeedUnconfirmedTaskError(
+ "wavespeed prediction status is unknown: "
+ f"http_status={status_code}, "
+ f"code={result_body.get('code') if isinstance(result_body, dict) else None}, "
+ f"detail={_redact_secret(str((result_body or {}).get('message') or ''), api_key)}",
+ prediction_id=prediction_id,
+ )
+ if not isinstance(result_data, dict):
+ raise WaveSpeedUnconfirmedTaskError(
+ "wavespeed prediction result payload is malformed",
+ prediction_id=prediction_id,
+ )
+ except WaveSpeedUnconfirmedTaskError:
+ raise
+ except Exception as e:
+ if not _is_wavespeed_retryable_error(e):
+ raise WaveSpeedUnconfirmedTaskError(
+ "wavespeed prediction polling failed and the task state is "
+ f"unknown: error={type(e).__name__}, "
+ f"detail={_redact_request_error(e, api_key)}",
+ prediction_id=prediction_id,
+ ) from e
+ consecutive_failures += 1
+ if consecutive_failures > WAVESPEED_MAX_POLL_RETRIES:
+ raise WaveSpeedUnconfirmedTaskError(
+ "wavespeed prediction polling failed after "
+ f"{WAVESPEED_MAX_POLL_RETRIES + 1} attempts, the task may "
+ "still be running remotely: "
+ f"error={type(e).__name__}, "
+ f"detail={_redact_request_error(e, api_key)}",
+ prediction_id=prediction_id,
+ ) from e
+ delay = WAVESPEED_RETRY_BASE_SECONDS * consecutive_failures
+ logger.warning(
+ "wavespeed prediction polling hit a transient error, retry the "
+ f"same task: id={prediction_id}, "
+ f"attempt={consecutive_failures}/{WAVESPEED_MAX_POLL_RETRIES}, "
+ f"error={type(e).__name__}, retry_in={delay:.1f}s"
+ )
+ time.sleep(delay)
+ continue
+
+ # 拿到一次有效响应就重置计数,只有连续失败才消耗重试额度。
+ consecutive_failures = 0
+ status = str(result_data.get("status") or "")
+ if status == "completed":
+ return result_data
+ if status in WAVESPEED_FAILURE_STATUSES:
+ logger.error(
+ "wavespeed prediction did not produce a video: "
+ f"id={prediction_id}, status={status}, "
+ f"detail={_redact_secret(str(result_data.get('error') or ''), api_key)}"
+ )
+ return None
+ if time.monotonic() > deadline:
+ # 远端任务仍在执行,本地无法确认最终状态,必须停止继续下单。
+ raise WaveSpeedUnconfirmedTaskError(
+ f"wavespeed prediction is still {status or 'pending'} after "
+ f"{WAVESPEED_RUN_TIMEOUT_SECONDS:.0f}s of local waiting",
+ prediction_id=prediction_id,
+ )
+ time.sleep(WAVESPEED_POLL_INTERVAL_SECONDS)
+
+
+def _save_wavespeed_video_with_retry(video_url: str, save_dir: str) -> str:
+ """
+ 下载已经付费生成的产物,失败时优先重试同一个地址。
+
+ 重新生成一次远端任务的代价是再付一次费,所以下载抖动必须先在原地址上
+ 做有限次退避重试,重试耗尽才放弃该片段。
+ """
+ for attempt in range(WAVESPEED_MAX_DOWNLOAD_RETRIES + 1):
+ try:
+ saved_video_path = save_video(video_url=video_url, save_dir=save_dir)
+ if saved_video_path:
+ return saved_video_path
+ failure_detail = "empty result"
+ except Exception as e:
+ failure_detail = (
+ f"error={type(e).__name__}, "
+ f"detail={_redact_request_error(e, video_url)}"
+ )
+ if attempt >= WAVESPEED_MAX_DOWNLOAD_RETRIES:
+ break
+ delay = WAVESPEED_RETRY_BASE_SECONDS * (attempt + 1)
+ logger.warning(
+ "failed to download generated video, retry the same url: "
+ f"attempt={attempt + 1}/{WAVESPEED_MAX_DOWNLOAD_RETRIES}, "
+ f"{failure_detail}, retry_in={delay:.1f}s"
+ )
+ time.sleep(delay)
+ logger.error(
+ "failed to download generated video after "
+ f"{WAVESPEED_MAX_DOWNLOAD_RETRIES + 1} attempts: {failure_detail}"
+ )
+ return ""
+
+
def save_video(video_url: str, save_dir: str = "") -> str:
if not save_dir:
save_dir = utils.storage_dir("cache_videos")
@@ -794,6 +1175,20 @@ def download_videos(
elif material_directory and not os.path.isdir(material_directory):
material_directory = ""
+ if source == "wavespeed":
+ # AI 生成按条计费,不能沿用库存源"先为全部关键词取回候选、再挑选"
+ # 的流程,否则会为用不到的片段付费。生成源改为逐段按需生成,凑够
+ # 所需时长立即停止;也不参与 24 小时搜索缓存——产物 URL 是会过期
+ # 的签名地址,且复用缓存会让不同任务反复得到同一段生成视频。
+ return _download_videos_wavespeed_on_demand(
+ task_id=task_id,
+ search_terms=search_terms,
+ video_aspect=video_aspect,
+ audio_duration=audio_duration,
+ max_clip_duration=max_clip_duration,
+ material_directory=material_directory,
+ )
+
if match_script_order:
return _download_videos_by_script_order(
task_id=task_id,
@@ -876,6 +1271,78 @@ def download_videos(
return video_paths
+def _download_videos_wavespeed_on_demand(
+ *,
+ task_id: str,
+ search_terms: List[str],
+ video_aspect: VideoAspect,
+ audio_duration: float,
+ max_clip_duration: int,
+ material_directory: str,
+) -> List[str]:
+ """
+ 按脚本片段顺序逐段生成 WaveSpeed 素材,凑够所需总时长立即停止。
+
+ 每个关键词天然对应一个脚本片段,生成即付费:先全量生成再挑选会为
+ 用不到的片段付费。这里每生成一段就立刻下载并累计有效时长(与库存
+ 流程一致,按片段时长封顶),累计超过所需配音时长后不再触发新的生成
+ 请求。单段失败按现有素材源约定跳过并继续下一段。
+ """
+ video_paths: List[str] = []
+ material_sources: list[dict[str, Any]] = []
+ total_duration = 0.0
+ for search_term in search_terms:
+ try:
+ video_items = generate_videos_wavespeed(
+ search_term=search_term,
+ minimum_duration=max_clip_duration,
+ video_aspect=video_aspect,
+ )
+ except WaveSpeedUnconfirmedTaskError as e:
+ # 已提交的付费任务状态不明:远端可能仍在运行或已经完成并计费。
+ # 继续为后续关键词下单会造成重复生成和重复扣费,因此就地停止,
+ # 并把 prediction id 留在日志里供人工在控制台找回产物。
+ logger.error(
+ "stop submitting new wavespeed tasks, the last submitted task "
+ f"is unconfirmed: prediction_id={e.prediction_id or 'unknown'}, "
+ f"detail={e}"
+ )
+ break
+ for item in video_items:
+ saved_video_path = _save_wavespeed_video_with_retry(
+ item.url, material_directory
+ )
+ if not saved_video_path:
+ continue
+ logger.info(f"video saved: {saved_video_path}")
+ video_paths.append(saved_video_path)
+ try:
+ material_sources.append(_material_source_record(item, saved_video_path))
+ except Exception as source_error:
+ # 与库存源一致:来源记录异常不能把已经付费生成并成功下载的
+ # 素材当作失败,更不能阻断视频生成。
+ logger.warning(
+ "failed to prepare material source record: "
+ f"provider={item.provider}, "
+ f"error={type(source_error).__name__}, detail={source_error}"
+ )
+ total_duration += min(max_clip_duration, item.duration)
+ # 用 >= 判断:累计时长恰好等于所需时长时已经够用,再生成会
+ # 多付一次费用。内外两处判断必须保持同一语义。
+ if total_duration >= audio_duration:
+ break
+ if total_duration >= audio_duration:
+ logger.info(
+ "generated materials cover the required duration, stop "
+ f"generating more clips: generated={total_duration:.1f}s, "
+ f"required={audio_duration:.1f}s"
+ )
+ break
+ logger.success(f"generated and downloaded {len(video_paths)} videos")
+ _persist_material_sources(task_id, material_sources)
+ return video_paths
+
+
def _download_videos_by_script_order(
task_id: str,
search_terms: List[str],
diff --git a/config.example.toml b/config.example.toml
index 89783b5f..9693ac98 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -50,7 +50,10 @@ tls_verify = true
# Video Materials / 视频素材
# -----------------------------------------------------------------------------
-# Available values: "pexels", "pixabay", "coverr", "loomloom", "local".
+# Available values: "pexels", "pixabay", "coverr", "wavespeed", "loomloom",
+# "local".
+# "wavespeed" generates brand-new clips with WaveSpeed AI text-to-video models
+# instead of searching stock footage; generation is billed per request.
# "loomloom" is a paid Shengsuan Cloud source and requires explicit
# confirmation in the WebUI before each generation request.
video_source = "pexels"
@@ -68,6 +71,19 @@ pixabay_api_keys = []
# Register at https://coverr.co/developers?ctx=header_navigation
coverr_api_keys = []
+# WaveSpeed AI generates clips from your script keywords with text-to-video
+# models. Create an API key at https://wavespeed.ai
+wavespeed_api_keys = []
+# Optional. Any WaveSpeed text-to-video model id that accepts
+# prompt / aspect_ratio / duration works here.
+# wavespeed_text_to_video_model = "bytedance/seedance-2.0-fast/text-to-video"
+# The default model only accepts durations of 4-15 seconds. Requested clip
+# durations outside the range are clamped automatically before submission
+# (extra footage is trimmed by the editing pipeline). Override only if your
+# chosen model supports a different range.
+# wavespeed_min_duration = 4
+# wavespeed_max_duration = 15
+
# Optional TwelveLabs integration for semantic material ranking and video QA.
# Install the optional dependency with: uv sync --extra twelvelabs
# Create an API key at https://playground.twelvelabs.io/
diff --git a/test/services/test_material.py b/test/services/test_material.py
index a10b15d6..73f19d2d 100644
--- a/test/services/test_material.py
+++ b/test/services/test_material.py
@@ -1069,5 +1069,592 @@ class TestCoverrProvider(unittest.TestCase):
self.assertEqual(result, ["/tmp/coverr-saved.mp4"])
+class TestWaveSpeedProvider(unittest.TestCase):
+ """
+ WaveSpeed AI 文生视频素材源。与其它素材源测试一致,全部用 unittest.mock
+ 替换 requests 和 time.sleep,CI 不依赖真实网络、真实 API key 和真实计费。
+ """
+
+ def setUp(self):
+ self.original_app_config = dict(config.app)
+ self.original_proxy_config = dict(config.proxy)
+ config.app["wavespeed_api_keys"] = ["wavespeed-key"]
+ config.app.pop("tls_verify", None)
+ config.proxy.clear()
+
+ def tearDown(self):
+ config.app.clear()
+ config.app.update(self.original_app_config)
+ config.proxy.clear()
+ config.proxy.update(self.original_proxy_config)
+
+ @staticmethod
+ def _json_response(payload):
+ return SimpleNamespace(json=lambda: payload)
+
+ def test_generate_wavespeed_submits_and_polls_to_completion(self):
+ """
+ 提交请求必须携带 Bearer 鉴权、模型 ID 路径和 prompt/aspect_ratio/duration
+ 三个生成参数;轮询到 completed 后把 outputs 转成 MaterialInfo。
+ """
+ submit_response = self._json_response(
+ {"code": 200, "message": "success", "data": {"id": "pred-123"}}
+ )
+ poll_responses = [
+ self._json_response(
+ {"code": 200, "data": {"id": "pred-123", "status": "processing"}}
+ ),
+ self._json_response(
+ {
+ "code": 200,
+ "data": {
+ "id": "pred-123",
+ "status": "completed",
+ "outputs": ["https://cdn.example.com/out.mp4?sig=abc"],
+ },
+ }
+ ),
+ ]
+
+ with (
+ patch(
+ "app.services.material.requests.post", return_value=submit_response
+ ) as post,
+ patch(
+ "app.services.material.requests.get", side_effect=poll_responses
+ ) as get,
+ patch("app.services.material.time.sleep") as sleep,
+ ):
+ results = material.generate_videos_wavespeed(
+ "sunrise over mountains",
+ minimum_duration=5,
+ video_aspect=material.VideoAspect.portrait,
+ )
+
+ self.assertEqual(len(results), 1)
+ item = results[0]
+ self.assertEqual(item.provider, "wavespeed")
+ # 签名 URL 必须原样保留,查询参数不能被剥离,否则下载会 403
+ self.assertEqual(item.url, "https://cdn.example.com/out.mp4?sig=abc")
+ self.assertEqual(item.duration, 5)
+ self.assertEqual(item.source_info["asset_id"], "pred-123")
+ self.assertEqual(item.source_info["search_term"], "sunrise over mountains")
+ # 生成产物地址是临时签名 URL,不允许写入来源记录
+ self.assertNotIn("source_page", item.source_info)
+
+ self.assertIn(
+ "/api/v3/bytedance/seedance-2.0-fast/text-to-video",
+ post.call_args.args[0],
+ )
+ self.assertEqual(
+ post.call_args.kwargs["headers"]["Authorization"],
+ "Bearer wavespeed-key",
+ )
+ self.assertEqual(
+ post.call_args.kwargs["json"],
+ {
+ "prompt": "sunrise over mountains",
+ "aspect_ratio": "9:16",
+ "duration": 5,
+ },
+ )
+ self.assertTrue(post.call_args.kwargs["verify"])
+ self.assertIn("/api/v3/predictions/pred-123/result", get.call_args.args[0])
+ # processing 状态下必须等待轮询间隔,不能空转打满远端接口
+ self.assertEqual(sleep.call_count, 1)
+
+ def test_generate_wavespeed_uses_configured_model_id(self):
+ """用户可以在配置中切换任意 WaveSpeed 文生视频模型。"""
+ config.app["wavespeed_text_to_video_model"] = "wavespeed-ai/custom-t2v"
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-9"}})
+ poll_response = self._json_response(
+ {
+ "code": 200,
+ "data": {
+ "id": "pred-9",
+ "status": "completed",
+ "outputs": ["https://cdn.example.com/a.mp4"],
+ },
+ }
+ )
+
+ with (
+ patch(
+ "app.services.material.requests.post", return_value=submit_response
+ ) as post,
+ patch("app.services.material.requests.get", return_value=poll_response),
+ ):
+ results = material.generate_videos_wavespeed(
+ "city timelapse",
+ minimum_duration=3,
+ video_aspect=material.VideoAspect.landscape,
+ )
+
+ self.assertEqual(len(results), 1)
+ self.assertIn("/api/v3/wavespeed-ai/custom-t2v", post.call_args.args[0])
+ self.assertEqual(post.call_args.kwargs["json"]["aspect_ratio"], "16:9")
+
+ def test_generate_wavespeed_returns_empty_on_failed_prediction(self):
+ """failed/cancelled/timeout 都按空结果返回,让上层跳过该关键词继续。"""
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-fail"}})
+ poll_response = self._json_response(
+ {
+ "code": 200,
+ "data": {
+ "id": "pred-fail",
+ "status": "failed",
+ "error": "content policy",
+ },
+ }
+ )
+
+ with (
+ patch("app.services.material.requests.post", return_value=submit_response),
+ patch("app.services.material.requests.get", return_value=poll_response),
+ ):
+ results = material.generate_videos_wavespeed("sunrise", minimum_duration=5)
+
+ self.assertEqual(results, [])
+
+ def test_generate_wavespeed_returns_empty_on_rejected_submission(self):
+ """非 200 envelope(如 key 无效)不能进入轮询,直接返回空结果。"""
+ submit_response = self._json_response({"code": 401, "message": "invalid api key"})
+
+ with (
+ patch("app.services.material.requests.post", return_value=submit_response),
+ patch("app.services.material.requests.get") as get,
+ ):
+ results = material.generate_videos_wavespeed("sunrise", minimum_duration=5)
+
+ self.assertEqual(results, [])
+ get.assert_not_called()
+
+ def test_generate_wavespeed_never_retries_submission_on_network_error(self):
+ """
+ 提交没有收到响应不代表任务没有创建,重发 POST 会重复生成、重复扣费。
+ 因此提交绝不自动重试,并按"状态不明"上抛,让上层停止继续下单。
+ """
+ with patch(
+ "app.services.material.requests.post",
+ side_effect=requests.exceptions.ConnectionError("boom"),
+ ) as post:
+ with self.assertRaises(material.WaveSpeedUnconfirmedTaskError):
+ material.generate_videos_wavespeed("sunrise", minimum_duration=5)
+
+ self.assertEqual(post.call_count, 1)
+
+ def test_generate_wavespeed_treats_server_error_submission_as_unconfirmed(self):
+ """5xx 可能发生在任务创建之后,状态不明,不能当作"没扣费"继续。"""
+ submit_response = SimpleNamespace(
+ status_code=502, json=lambda: {"code": 502, "message": "bad gateway"}
+ )
+
+ with patch("app.services.material.requests.post", return_value=submit_response):
+ with self.assertRaises(material.WaveSpeedUnconfirmedTaskError):
+ material.generate_videos_wavespeed("sunrise", minimum_duration=5)
+
+ def test_generate_wavespeed_retries_transient_poll_failures_on_same_task(self):
+ """
+ 轮询遇到 429/5xx 或网络异常时,必须带着原来的 prediction id 退避重试,
+ 绝不能重新提交一次付费生成任务。
+ """
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-r1"}})
+ rate_limited = SimpleNamespace(status_code=429, json=lambda: {"code": 429})
+ completed = self._json_response(
+ {
+ "code": 200,
+ "data": {
+ "id": "pred-r1",
+ "status": "completed",
+ "outputs": ["https://cdn.example.com/r1.mp4"],
+ },
+ }
+ )
+
+ with (
+ patch(
+ "app.services.material.requests.post", return_value=submit_response
+ ) as post,
+ patch(
+ "app.services.material.requests.get",
+ side_effect=[
+ rate_limited,
+ requests.exceptions.ConnectionError("boom"),
+ completed,
+ ],
+ ) as get,
+ patch("app.services.material.time.sleep") as sleep,
+ ):
+ results = material.generate_videos_wavespeed("sunrise", minimum_duration=5)
+
+ self.assertEqual(len(results), 1)
+ # 只提交一次;三次 GET 全部指向同一个 prediction id
+ self.assertEqual(post.call_count, 1)
+ self.assertEqual(get.call_count, 3)
+ for call in get.call_args_list:
+ self.assertIn("/api/v3/predictions/pred-r1/result", call.args[0])
+ # 线性退避:第 n 次重试等待 base * n
+ self.assertEqual([call.args[0] for call in sleep.call_args_list], [1.0, 2.0])
+
+ def test_generate_wavespeed_raises_unconfirmed_after_poll_retries_exhausted(self):
+ """
+ 连续临时失败超过上限后,任务状态仍然不明:任务可能还在远端运行。
+ 必须上抛并带上 prediction id,而不是当作失败让流程继续下单。
+ """
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-r2"}})
+
+ with (
+ patch("app.services.material.requests.post", return_value=submit_response),
+ patch(
+ "app.services.material.requests.get",
+ side_effect=requests.exceptions.ConnectionError("boom"),
+ ) as get,
+ patch("app.services.material.time.sleep"),
+ ):
+ with self.assertRaises(material.WaveSpeedUnconfirmedTaskError) as ctx:
+ material.generate_videos_wavespeed("sunrise", minimum_duration=5)
+
+ self.assertEqual(ctx.exception.prediction_id, "pred-r2")
+ self.assertEqual(get.call_count, material.WAVESPEED_MAX_POLL_RETRIES + 1)
+
+ def test_generate_wavespeed_raises_unconfirmed_on_local_wait_timeout(self):
+ """本地等待超时,远端任务仍在运行,状态不明,不能继续提交新任务。"""
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-r3"}})
+ processing = self._json_response(
+ {"code": 200, "data": {"id": "pred-r3", "status": "processing"}}
+ )
+ clock = iter([0.0, 0.0, material.WAVESPEED_RUN_TIMEOUT_SECONDS + 1])
+
+ with (
+ patch("app.services.material.requests.post", return_value=submit_response),
+ patch("app.services.material.requests.get", return_value=processing),
+ patch(
+ "app.services.material.time.monotonic", side_effect=lambda: next(clock)
+ ),
+ patch("app.services.material.time.sleep"),
+ ):
+ with self.assertRaises(material.WaveSpeedUnconfirmedTaskError) as ctx:
+ material.generate_videos_wavespeed("sunrise", minimum_duration=5)
+
+ self.assertEqual(ctx.exception.prediction_id, "pred-r3")
+
+ def test_download_videos_wavespeed_stops_submitting_after_unconfirmed_task(self):
+ """
+ 回归:某个片段的任务状态不明时,后续关键词绝不能再触发新的付费生成
+ 请求——否则第一个任务可能仍在运行/已完成,造成重复生成和额外扣费。
+ 已经下载成功的素材照常返回。
+ """
+ first_item = self._generated_item("term-1", "https://cdn.example.com/1.mp4")
+
+ def fake_generate(search_term, minimum_duration, video_aspect):
+ if search_term == "term-1":
+ return [first_item]
+ raise material.WaveSpeedUnconfirmedTaskError(
+ "state unknown", prediction_id="pred-stuck"
+ )
+
+ with (
+ patch(
+ "app.services.material.generate_videos_wavespeed",
+ side_effect=fake_generate,
+ ) as generate,
+ patch(
+ "app.services.material.save_video",
+ return_value="/tmp/1.mp4",
+ ),
+ ):
+ result = material.download_videos(
+ task_id="test-wavespeed-unconfirmed",
+ search_terms=["term-1", "term-2", "term-3"],
+ source="wavespeed",
+ audio_duration=100,
+ max_clip_duration=5,
+ )
+
+ # term-2 抛出状态不明后立即停止,term-3 不能再产生生成请求
+ self.assertEqual(generate.call_count, 2)
+ self.assertEqual(result, ["/tmp/1.mp4"])
+
+ def test_download_videos_wavespeed_retries_original_download_url(self):
+ """
+ 产物已经付费生成,下载抖动必须优先重试同一个签名地址,而不是重新
+ 提交一次付费生成任务。
+ """
+ item = self._generated_item("term-1", "https://cdn.example.com/1.mp4")
+
+ with (
+ patch(
+ "app.services.material.generate_videos_wavespeed",
+ return_value=[item],
+ ) as generate,
+ patch(
+ "app.services.material.save_video",
+ side_effect=[
+ requests.exceptions.ConnectionError("boom"),
+ "/tmp/1.mp4",
+ ],
+ ) as save,
+ patch("app.services.material.time.sleep"),
+ ):
+ result = material.download_videos(
+ task_id="test-wavespeed-download-retry",
+ search_terms=["term-1"],
+ source="wavespeed",
+ audio_duration=5,
+ max_clip_duration=5,
+ )
+
+ self.assertEqual(result, ["/tmp/1.mp4"])
+ # 重试打在同一个地址上,且没有触发第二次付费生成
+ self.assertEqual(save.call_count, 2)
+ self.assertEqual(generate.call_count, 1)
+ for call in save.call_args_list:
+ self.assertEqual(
+ call.kwargs.get("video_url") or call.args[0],
+ "https://cdn.example.com/1.mp4",
+ )
+
+ def test_download_videos_wavespeed_bypasses_search_cache(self):
+ """
+ 生成源不参与 24 小时搜索缓存:签名 URL 会过期,复用缓存还会让不同
+ 任务反复拿到同一段生成视频。download_videos 必须直接调用生成函数。
+ """
+ generated_item = material.MaterialInfo()
+ generated_item.provider = "wavespeed"
+ generated_item.url = "https://cdn.example.com/out.mp4?sig=abc"
+ generated_item.duration = 5
+ generated_item.source_info = {
+ "provider": "wavespeed",
+ "search_term": "sunrise",
+ "asset_id": "pred-123",
+ }
+
+ with (
+ patch(
+ "app.services.material.generate_videos_wavespeed",
+ return_value=[generated_item],
+ ) as generate,
+ patch("app.services.material._search_videos_with_cache") as cached_search,
+ patch(
+ "app.services.material.save_video",
+ return_value="/tmp/wavespeed-saved.mp4",
+ ) as save,
+ ):
+ result = material.download_videos(
+ task_id="test-wavespeed",
+ search_terms=["sunrise"],
+ source="wavespeed",
+ audio_duration=5,
+ max_clip_duration=5,
+ )
+
+ self.assertEqual(generate.call_count, 1)
+ cached_search.assert_not_called()
+ save_url = save.call_args.kwargs.get("video_url") or save.call_args.args[0]
+ self.assertEqual(save_url, "https://cdn.example.com/out.mp4?sig=abc")
+ self.assertEqual(result, ["/tmp/wavespeed-saved.mp4"])
+
+ def test_generate_wavespeed_clamps_duration_to_model_minimum(self):
+ """
+ WebUI 默认片段时长 3 秒,而默认模型只接受 4-15 秒;直接透传会被 API
+ 拒绝。请求必须收敛到模型下限,多出的时长由现有剪辑流程按片段时长裁掉。
+ """
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-c1"}})
+ poll_response = self._json_response(
+ {
+ "code": 200,
+ "data": {
+ "id": "pred-c1",
+ "status": "completed",
+ "outputs": ["https://cdn.example.com/c1.mp4"],
+ },
+ }
+ )
+
+ with (
+ patch(
+ "app.services.material.requests.post", return_value=submit_response
+ ) as post,
+ patch("app.services.material.requests.get", return_value=poll_response),
+ ):
+ results = material.generate_videos_wavespeed("sunrise", minimum_duration=3)
+
+ self.assertEqual(post.call_args.kwargs["json"]["duration"], 4)
+ # MaterialInfo 记录实际生成时长,时长核算和剪辑按真实素材长度进行
+ self.assertEqual(results[0].duration, 4)
+
+ def test_generate_wavespeed_clamps_duration_to_model_maximum(self):
+ """超过模型上限的请求收敛到上限,不能提交必然失败的远端请求。"""
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-c2"}})
+ poll_response = self._json_response(
+ {
+ "code": 200,
+ "data": {
+ "id": "pred-c2",
+ "status": "completed",
+ "outputs": ["https://cdn.example.com/c2.mp4"],
+ },
+ }
+ )
+
+ with (
+ patch(
+ "app.services.material.requests.post", return_value=submit_response
+ ) as post,
+ patch("app.services.material.requests.get", return_value=poll_response),
+ ):
+ results = material.generate_videos_wavespeed("sunrise", minimum_duration=20)
+
+ self.assertEqual(post.call_args.kwargs["json"]["duration"], 15)
+ self.assertEqual(results[0].duration, 15)
+
+ def test_generate_wavespeed_duration_bounds_are_configurable(self):
+ """切换到其它模型时,用户可以在配置中同步调整支持的时长区间。"""
+ config.app["wavespeed_min_duration"] = 2
+ config.app["wavespeed_max_duration"] = 8
+ submit_response = self._json_response({"code": 200, "data": {"id": "pred-c3"}})
+ poll_response = self._json_response(
+ {
+ "code": 200,
+ "data": {
+ "id": "pred-c3",
+ "status": "completed",
+ "outputs": ["https://cdn.example.com/c3.mp4"],
+ },
+ }
+ )
+
+ with (
+ patch(
+ "app.services.material.requests.post", return_value=submit_response
+ ) as post,
+ patch("app.services.material.requests.get", return_value=poll_response),
+ ):
+ material.generate_videos_wavespeed("sunrise", minimum_duration=3)
+
+ self.assertEqual(post.call_args.kwargs["json"]["duration"], 3)
+
+ @staticmethod
+ def _generated_item(term, url, duration=5):
+ item = material.MaterialInfo()
+ item.provider = "wavespeed"
+ item.url = url
+ item.duration = duration
+ item.source_info = {
+ "provider": "wavespeed",
+ "search_term": term,
+ "asset_id": f"pred-{term}",
+ }
+ return item
+
+ def test_download_videos_wavespeed_generates_on_demand_and_stops(self):
+ """
+ 生成按条计费,不能先为全部关键词生成再挑选。素材必须逐段按需生成,
+ 累计有效时长(按片段时长封顶)超过所需配音时长后,后续关键词不再
+ 触发任何生成请求。
+ """
+ generated = {
+ "term-1": [self._generated_item("term-1", "https://cdn.example.com/1.mp4")],
+ "term-2": [self._generated_item("term-2", "https://cdn.example.com/2.mp4")],
+ "term-3": [self._generated_item("term-3", "https://cdn.example.com/3.mp4")],
+ }
+
+ def fake_generate(search_term, minimum_duration, video_aspect):
+ return generated[search_term]
+
+ with (
+ patch(
+ "app.services.material.generate_videos_wavespeed",
+ side_effect=fake_generate,
+ ) as generate,
+ patch(
+ "app.services.material.save_video",
+ side_effect=lambda video_url, save_dir="": f"/tmp/{video_url.rsplit('/', 1)[-1]}",
+ ),
+ ):
+ result = material.download_videos(
+ task_id="test-wavespeed-lazy",
+ search_terms=["term-1", "term-2", "term-3"],
+ source="wavespeed",
+ audio_duration=8,
+ max_clip_duration=5,
+ )
+
+ # 5s + 5s > 8s,第三个关键词不能再产生付费生成请求
+ self.assertEqual(generate.call_count, 2)
+ self.assertEqual(
+ [call.kwargs["search_term"] for call in generate.call_args_list],
+ ["term-1", "term-2"],
+ )
+ self.assertEqual(result, ["/tmp/1.mp4", "/tmp/2.mp4"])
+
+ def test_download_videos_wavespeed_stops_when_duration_exactly_covered(self):
+ """
+ 边界回归:配音 10 秒、每段 5 秒时,累计恰好等于所需时长即已够用,
+ 第 3 个关键词不能再触发付费生成请求(停止判断必须是 >= 而不是 >)。
+ """
+ generated = {
+ "term-1": [self._generated_item("term-1", "https://cdn.example.com/1.mp4")],
+ "term-2": [self._generated_item("term-2", "https://cdn.example.com/2.mp4")],
+ "term-3": [self._generated_item("term-3", "https://cdn.example.com/3.mp4")],
+ }
+
+ def fake_generate(search_term, minimum_duration, video_aspect):
+ return generated[search_term]
+
+ with (
+ patch(
+ "app.services.material.generate_videos_wavespeed",
+ side_effect=fake_generate,
+ ) as generate,
+ patch(
+ "app.services.material.save_video",
+ side_effect=lambda video_url, save_dir="": f"/tmp/{video_url.rsplit('/', 1)[-1]}",
+ ),
+ ):
+ result = material.download_videos(
+ task_id="test-wavespeed-exact",
+ search_terms=["term-1", "term-2", "term-3"],
+ source="wavespeed",
+ audio_duration=10,
+ max_clip_duration=5,
+ )
+
+ # 5s + 5s == 10s,恰好覆盖,第 3 段绝不能生成
+ self.assertEqual(generate.call_count, 2)
+ self.assertEqual(result, ["/tmp/1.mp4", "/tmp/2.mp4"])
+
+ def test_download_videos_wavespeed_skips_failed_segment_and_continues(self):
+ """单个片段生成失败(空结果)时跳过该关键词,继续为后续片段生成。"""
+ generated = {
+ "term-1": [],
+ "term-2": [self._generated_item("term-2", "https://cdn.example.com/2.mp4")],
+ }
+
+ def fake_generate(search_term, minimum_duration, video_aspect):
+ return generated[search_term]
+
+ with (
+ patch(
+ "app.services.material.generate_videos_wavespeed",
+ side_effect=fake_generate,
+ ) as generate,
+ patch(
+ "app.services.material.save_video",
+ return_value="/tmp/wavespeed-2.mp4",
+ ),
+ ):
+ result = material.download_videos(
+ task_id="test-wavespeed-skip",
+ search_terms=["term-1", "term-2"],
+ source="wavespeed",
+ audio_duration=4,
+ max_clip_duration=5,
+ )
+
+ self.assertEqual(generate.call_count, 2)
+ self.assertEqual(result, ["/tmp/wavespeed-2.mp4"])
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/webui/Main.py b/webui/Main.py
index de5d3f20..2d65acc2 100644
--- a/webui/Main.py
+++ b/webui/Main.py
@@ -521,6 +521,7 @@ def _initialize_session_state():
"loomloom_video_input_signature": "",
"loomloom_video_client_request_id": "",
"loomloom_video_confirm_charge": False,
+ "wavespeed_confirm_charge": False,
# AI 视频按素材段计费,默认只生成一段,用户确认效果后再主动增加数量。
"loomloom_video_scene_count": _saved_ui_number(
"loomloom_video_scene_count",
@@ -2857,6 +2858,15 @@ def _render_settings_dialog():
)
_save_material_api_keys("coverr_api_keys", coverr_api_key)
+ wavespeed_api_key = _get_material_api_keys("wavespeed_api_keys")
+ wavespeed_api_key = st.text_input(
+ tr("WaveSpeed API Key"),
+ value=wavespeed_api_key,
+ type="password",
+ key="wavespeed_api_keys_input",
+ )
+ _save_material_api_keys("wavespeed_api_keys", wavespeed_api_key)
+
_save_runtime_config()
@@ -3618,6 +3628,7 @@ def _render_video_settings(panel, params):
(tr("Pexels"), "pexels"),
(tr("Pixabay"), "pixabay"),
(tr("Coverr"), "coverr"),
+ (tr("WaveSpeed AI Video"), "wavespeed"),
(tr("Shengsuan Cloud AI Video"), "loomloom"),
(tr("Local file"), "local"),
]
@@ -3635,6 +3646,9 @@ def _render_video_settings(panel, params):
)
_set_runtime_config("app", "video_source", params.video_source)
+ if params.video_source == "wavespeed":
+ st.caption(tr("WaveSpeed AI Video Help"))
+
if params.video_source == "local":
# Streamlit 的文件类型校验对扩展名大小写敏感,这里同时放行大小写两种形式。
local_file_types = sorted(
@@ -3828,9 +3842,44 @@ def _render_video_settings(panel, params):
if params.video_source == "loomloom":
_render_loomloom_video_settings(params)
+
+ if params.video_source == "wavespeed":
+ _render_wavespeed_video_settings(params)
return uploaded_files
+def _render_wavespeed_video_settings(params):
+ """
+ 渲染 WaveSpeed 生成数量估算与计费确认。
+
+ 生成按条计费,提交前必须让用户看到大致会生成多少段。估算完全在本地
+ 完成:用配音时长估算区间除以片段时长得到需要覆盖的片段数。素材流程
+ 本身按需逐段生成、凑够所需时长即停,因此实际生成数以运行时为准,
+ 估算只用于量级提示,不参与任务执行。
+ """
+ clip_duration = max(int(params.video_clip_duration or 1), 1)
+ video_count = max(int(params.video_count or 1), 1)
+ estimated_range = _estimate_voiceover_duration_range(
+ str(params.video_script or ""),
+ params.voice_rate,
+ )
+ if estimated_range:
+ min_clips = max(math.ceil(estimated_range[0] * video_count / clip_duration), 1)
+ max_clips = max(
+ math.ceil(estimated_range[1] * video_count / clip_duration), min_clips
+ )
+ st.warning(
+ tr("WaveSpeed Billing Notice").format(min=min_clips, max=max_clips)
+ )
+ else:
+ st.warning(tr("WaveSpeed Billing Notice Without Script"))
+ st.checkbox(
+ tr("Confirm WaveSpeed Charge"),
+ key="wavespeed_confirm_charge",
+ help=tr("Confirm WaveSpeed Charge Help"),
+ )
+
+
def _estimate_voiceover_duration_range(
text: str, voice_rate: float
) -> tuple[float, float] | None:
@@ -5453,6 +5502,7 @@ def _render_generation_controls(
"pexels",
"pixabay",
"coverr",
+ "wavespeed",
"loomloom",
"local",
]:
@@ -5481,6 +5531,20 @@ def _render_generation_controls(
st.error(tr("Please Enter the Coverr API Key"))
st.stop()
+ if params.video_source == "wavespeed" and not config.app.get(
+ "wavespeed_api_keys", ""
+ ):
+ _remove_active_generation_task(task_id)
+ st.error(tr("Please Enter the WaveSpeed API Key"))
+ st.stop()
+
+ if params.video_source == "wavespeed" and not st.session_state.get(
+ "wavespeed_confirm_charge", False
+ ):
+ _remove_active_generation_task(task_id)
+ st.error(tr("Confirm WaveSpeed Charge Required"))
+ st.stop()
+
loomloom_video_request = None
if params.video_source == "loomloom":
current_batch, current_signature = _current_loomloom_video_quote_context(
diff --git a/webui/i18n/de.json b/webui/i18n/de.json
index 7641d73b..e3a1bc6b 100644
--- a/webui/i18n/de.json
+++ b/webui/i18n/de.json
@@ -310,6 +310,15 @@
"Video Source Settings": "**Videoquellen-Einstellungen**",
"Coverr": "Coverr",
"Coverr API Key": "Coverr API-Schlüssel ([API-Schlüssel holen](https://coverr.co/developers?ctx=header_navigation))",
- "Please Enter the Coverr API Key": "Bitte geben Sie den **Coverr API-Schlüssel** ein"
+ "Please Enter the Coverr API Key": "Bitte geben Sie den **Coverr API-Schlüssel** ein",
+ "WaveSpeed AI Video": "WaveSpeed-KI-Video",
+ "WaveSpeed AI Video Help": "Erzeugt mit WaveSpeed-KI-Text-zu-Video-Modellen neue Clips aus Ihren Skript-Stichwörtern, statt Stock-Material zu durchsuchen. Die Generierung wird von WaveSpeed pro Clip berechnet.",
+ "WaveSpeed API Key": "WaveSpeed-API-Schlüssel ([API-Schlüssel erhalten](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Bitte geben Sie den **WaveSpeed-API-Schlüssel** ein",
+ "WaveSpeed Billing Notice": "Jeder generierte Clip wird von WaveSpeed einzeln berechnet. Basierend auf der geschätzten Sprecherdauer und der Clip-Länge werden voraussichtlich etwa {min}-{max} Clip(s) generiert. Die Generierung erfolgt Segment für Segment und stoppt, sobald genügend Material vorliegt.",
+ "WaveSpeed Billing Notice Without Script": "Jeder generierte Clip wird von WaveSpeed einzeln berechnet. Geben Sie das Videoskript ein oder generieren Sie es, um eine geschätzte Clip-Anzahl zu sehen. Die Generierung erfolgt Segment für Segment und stoppt, sobald genügend Material vorliegt.",
+ "Confirm WaveSpeed Charge": "Ich verstehe, dass die WaveSpeed-Videogenerierung ein kostenpflichtiger Dienst ist",
+ "Confirm WaveSpeed Charge Help": "Clips werden bedarfsgesteuert Segment für Segment generiert; die Generierung stoppt, sobald das Material die Sprecherdauer abdeckt. Die Gebühren berechnet WaveSpeed pro generiertem Clip.",
+ "Confirm WaveSpeed Charge Required": "Bitte bestätigen Sie die WaveSpeed-Generierungskosten, bevor Sie das Video erstellen."
}
}
diff --git a/webui/i18n/en.json b/webui/i18n/en.json
index 880da031..6108b763 100644
--- a/webui/i18n/en.json
+++ b/webui/i18n/en.json
@@ -326,6 +326,15 @@
"Coverr": "Coverr",
"Coverr API Key": "Coverr API Key ([Get API Key](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "Please Enter the **Coverr API Key**",
+ "WaveSpeed AI Video": "WaveSpeed AI Video",
+ "WaveSpeed AI Video Help": "Generate brand-new clips from your script keywords with WaveSpeed AI text-to-video models instead of searching stock footage. Generation is billed per clip by WaveSpeed.",
+ "WaveSpeed API Key": "WaveSpeed API Key ([Get API Key](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Please Enter the **WaveSpeed API Key**",
+ "WaveSpeed Billing Notice": "Each generated clip is billed by WaveSpeed. Based on the estimated voiceover duration and the clip duration, roughly {min}-{max} clip(s) will be generated. Generation runs segment by segment and stops as soon as enough footage is collected.",
+ "WaveSpeed Billing Notice Without Script": "Each generated clip is billed by WaveSpeed. Enter or generate the video script to see an estimated clip count. Generation runs segment by segment and stops as soon as enough footage is collected.",
+ "Confirm WaveSpeed Charge": "I understand WaveSpeed video generation is a paid service",
+ "Confirm WaveSpeed Charge Help": "Clips are generated on demand, one script segment at a time, and generation stops once the collected footage covers the voiceover duration. Fees are charged by WaveSpeed per generated clip.",
+ "Confirm WaveSpeed Charge Required": "Please confirm the WaveSpeed video generation charge before generating the video.",
"Video Encoder": "Video Encoder",
"Default Video Encoder": "Default (Recommended)",
"Video Encoder Help": "Advanced option. Default follows the app's stable encoder policy, currently libx264. If a selected hardware encoder is unavailable, the app automatically falls back to libx264.",
diff --git a/webui/i18n/es.json b/webui/i18n/es.json
index 83e8ad8d..fe1debf0 100644
--- a/webui/i18n/es.json
+++ b/webui/i18n/es.json
@@ -308,6 +308,15 @@
"Coverr": "Coverr",
"Coverr API Key": "Coverr API Key ([Obtener API Key](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "Introduce la **API Key de Coverr**",
+ "WaveSpeed AI Video": "Vídeo IA de WaveSpeed",
+ "WaveSpeed AI Video Help": "Genera clips completamente nuevos a partir de las palabras clave del guion con los modelos de texto a vídeo de WaveSpeed AI, en lugar de buscar material de archivo. La generación se factura por clip en WaveSpeed.",
+ "WaveSpeed API Key": "Clave de API de WaveSpeed ([Obtener Clave de API](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Por favor, introduce la **Clave de API de WaveSpeed**",
+ "WaveSpeed Billing Notice": "Cada clip generado se factura por WaveSpeed. Según la duración estimada de la locución y la duración del clip, se generarán aproximadamente {min}-{max} clip(s). La generación avanza segmento a segmento y se detiene en cuanto hay material suficiente.",
+ "WaveSpeed Billing Notice Without Script": "Cada clip generado se factura por WaveSpeed. Introduce o genera el guion del vídeo para ver una estimación del número de clips. La generación avanza segmento a segmento y se detiene en cuanto hay material suficiente.",
+ "Confirm WaveSpeed Charge": "Entiendo que la generación de vídeo de WaveSpeed es un servicio de pago",
+ "Confirm WaveSpeed Charge Help": "Los clips se generan bajo demanda, segmento a segmento, y la generación se detiene cuando el material cubre la duración de la locución. WaveSpeed cobra por cada clip generado.",
+ "Confirm WaveSpeed Charge Required": "Por favor, confirma el coste de generación de WaveSpeed antes de generar el vídeo.",
"Video Encoder": "Codificador de vídeo",
"Default Video Encoder": "Predeterminado (recomendado)",
"Video Encoder Help": "Opción avanzada. Predeterminado sigue la política estable de la aplicación, actualmente libx264. Si un codificador de hardware no está disponible, la aplicación vuelve automáticamente a libx264."
diff --git a/webui/i18n/id.json b/webui/i18n/id.json
index 6f834cf5..903c36b0 100644
--- a/webui/i18n/id.json
+++ b/webui/i18n/id.json
@@ -308,6 +308,15 @@
"Coverr": "Coverr",
"Coverr API Key": "Kunci API Coverr ([Dapatkan Kunci API](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "Silakan Masukkan **Kunci API Coverr**",
+ "WaveSpeed AI Video": "Video AI WaveSpeed",
+ "WaveSpeed AI Video Help": "Hasilkan klip baru dari kata kunci naskah Anda dengan model text-to-video WaveSpeed AI, bukan mencari stok video. Pembuatan ditagih per klip oleh WaveSpeed.",
+ "WaveSpeed API Key": "Kunci API WaveSpeed ([Dapatkan Kunci API](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Silakan masukkan **Kunci API WaveSpeed**",
+ "WaveSpeed Billing Notice": "Setiap klip yang dihasilkan ditagih oleh WaveSpeed. Berdasarkan perkiraan durasi sulih suara dan durasi klip, sekitar {min}-{max} klip akan dihasilkan. Pembuatan berjalan per segmen dan berhenti begitu materi mencukupi.",
+ "WaveSpeed Billing Notice Without Script": "Setiap klip yang dihasilkan ditagih oleh WaveSpeed. Masukkan atau buat naskah video untuk melihat perkiraan jumlah klip. Pembuatan berjalan per segmen dan berhenti begitu materi mencukupi.",
+ "Confirm WaveSpeed Charge": "Saya memahami bahwa pembuatan video WaveSpeed adalah layanan berbayar",
+ "Confirm WaveSpeed Charge Help": "Klip dibuat sesuai kebutuhan, segmen demi segmen, dan pembuatan berhenti begitu materi mencakup durasi sulih suara. Biaya ditagih WaveSpeed per klip yang dihasilkan.",
+ "Confirm WaveSpeed Charge Required": "Harap konfirmasi biaya pembuatan video WaveSpeed sebelum membuat video.",
"Video Encoder": "Encoder Video",
"Default Video Encoder": "Default (Direkomendasikan)",
"Video Encoder Help": "Opsi lanjutan. Default mengikuti kebijakan encoder stabil aplikasi, saat ini libx264. Jika encoder perangkat keras tidak tersedia, aplikasi otomatis kembali ke libx264."
diff --git a/webui/i18n/pt.json b/webui/i18n/pt.json
index f592f7fc..cc93ce92 100644
--- a/webui/i18n/pt.json
+++ b/webui/i18n/pt.json
@@ -308,6 +308,15 @@
"Coverr": "Coverr",
"Coverr API Key": "Chave de API do Coverr ([Obter Chave de API](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "Por favor, insira a **Chave de API do Coverr**",
+ "WaveSpeed AI Video": "Vídeo de IA WaveSpeed",
+ "WaveSpeed AI Video Help": "Gere clipes totalmente novos a partir das palavras-chave do roteiro com os modelos de texto para vídeo da WaveSpeed AI, em vez de pesquisar vídeos de banco. A geração é cobrada por clipe pela WaveSpeed.",
+ "WaveSpeed API Key": "Chave de API do WaveSpeed ([Obter Chave de API](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Por favor, insira a **Chave de API do WaveSpeed**",
+ "WaveSpeed Billing Notice": "Cada clipe gerado é cobrado pela WaveSpeed. Com base na duração estimada da narração e na duração do clipe, serão gerados aproximadamente {min}-{max} clipe(s). A geração avança segmento a segmento e para assim que houver material suficiente.",
+ "WaveSpeed Billing Notice Without Script": "Cada clipe gerado é cobrado pela WaveSpeed. Insira ou gere o roteiro do vídeo para ver uma estimativa do número de clipes. A geração avança segmento a segmento e para assim que houver material suficiente.",
+ "Confirm WaveSpeed Charge": "Entendo que a geração de vídeo da WaveSpeed é um serviço pago",
+ "Confirm WaveSpeed Charge Help": "Os clipes são gerados sob demanda, segmento a segmento, e a geração para quando o material cobre a duração da narração. A WaveSpeed cobra por clipe gerado.",
+ "Confirm WaveSpeed Charge Required": "Confirme o custo de geração da WaveSpeed antes de gerar o vídeo.",
"Video Encoder": "Codificador de vídeo",
"Default Video Encoder": "Padrão (recomendado)",
"Video Encoder Help": "Opção avançada. Padrão segue a política estável do aplicativo, atualmente libx264. Se um codificador de hardware não estiver disponível, o aplicativo retorna automaticamente para libx264."
diff --git a/webui/i18n/ru.json b/webui/i18n/ru.json
index 274e1703..12f0f0ed 100644
--- a/webui/i18n/ru.json
+++ b/webui/i18n/ru.json
@@ -304,6 +304,15 @@
"Coverr": "Coverr",
"Coverr API Key": "API-ключ Coverr ([Получить ключ](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "Введите **API-ключ Coverr**",
+ "WaveSpeed AI Video": "ИИ-видео WaveSpeed",
+ "WaveSpeed AI Video Help": "Создавайте новые клипы по ключевым словам сценария с помощью моделей текст-в-видео WaveSpeed AI вместо поиска стоковых материалов. Генерация оплачивается за клип на стороне WaveSpeed.",
+ "WaveSpeed API Key": "API-ключ WaveSpeed ([Получить API-ключ](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Пожалуйста, введите **API-ключ WaveSpeed**",
+ "WaveSpeed Billing Notice": "Каждый сгенерированный клип оплачивается WaveSpeed отдельно. Исходя из оценочной длительности озвучки и длительности клипа, будет сгенерировано примерно {min}-{max} клип(ов). Генерация идёт по сегментам и останавливается, как только материала достаточно.",
+ "WaveSpeed Billing Notice Without Script": "Каждый сгенерированный клип оплачивается WaveSpeed отдельно. Введите или сгенерируйте сценарий видео, чтобы увидеть оценку количества клипов. Генерация идёт по сегментам и останавливается, как только материала достаточно.",
+ "Confirm WaveSpeed Charge": "Я понимаю, что генерация видео WaveSpeed — платная услуга",
+ "Confirm WaveSpeed Charge Help": "Клипы генерируются по требованию, сегмент за сегментом; генерация останавливается, когда материал покрывает длительность озвучки. WaveSpeed взимает плату за каждый сгенерированный клип.",
+ "Confirm WaveSpeed Charge Required": "Пожалуйста, подтвердите стоимость генерации WaveSpeed перед созданием видео.",
"Video Encoder": "Видеокодер",
"Default Video Encoder": "По умолчанию (рекомендуется)",
"Video Encoder Help": "Дополнительная настройка. Значение по умолчанию следует стабильной политике приложения, сейчас это libx264. Если аппаратный кодер недоступен, приложение автоматически вернется к libx264.",
diff --git a/webui/i18n/tr.json b/webui/i18n/tr.json
index fe666f4a..fbd94c4e 100644
--- a/webui/i18n/tr.json
+++ b/webui/i18n/tr.json
@@ -308,6 +308,15 @@
"Coverr": "Coverr",
"Coverr API Key": "Coverr API Anahtarı ([API Anahtarı Al](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "Lütfen **Coverr API Anahtarını** girin",
+ "WaveSpeed AI Video": "WaveSpeed Yapay Zeka Videosu",
+ "WaveSpeed AI Video Help": "Stok görüntü aramak yerine, WaveSpeed AI metinden videoya modelleriyle senaryo anahtar kelimelerinizden yepyeni klipler üretin. Üretim, WaveSpeed tarafından klip başına ücretlendirilir.",
+ "WaveSpeed API Key": "WaveSpeed API Anahtarı ([API Anahtarı Al](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Lütfen **WaveSpeed API Anahtarını** girin",
+ "WaveSpeed Billing Notice": "Üretilen her klip WaveSpeed tarafından ayrı ücretlendirilir. Tahmini seslendirme süresi ve klip süresine göre yaklaşık {min}-{max} klip üretilecektir. Üretim bölüm bölüm ilerler ve yeterli görüntü toplanır toplanmaz durur.",
+ "WaveSpeed Billing Notice Without Script": "Üretilen her klip WaveSpeed tarafından ayrı ücretlendirilir. Tahmini klip sayısını görmek için video senaryosunu girin veya oluşturun. Üretim bölüm bölüm ilerler ve yeterli görüntü toplanır toplanmaz durur.",
+ "Confirm WaveSpeed Charge": "WaveSpeed video üretiminin ücretli bir hizmet olduğunu anlıyorum",
+ "Confirm WaveSpeed Charge Help": "Klipler ihtiyaç oldukça, senaryo bölümü bölümü üretilir; görüntüler seslendirme süresini karşıladığında üretim durur. Ücretler, üretilen klip başına WaveSpeed tarafından alınır.",
+ "Confirm WaveSpeed Charge Required": "Lütfen videoyu oluşturmadan önce WaveSpeed üretim ücretini onaylayın.",
"Video Encoder": "Video Kodlayıcı",
"Default Video Encoder": "Varsayılan (Önerilen)",
"Video Encoder Help": "Gelişmiş seçenek. Varsayılan, uygulamanın kararlı kodlayıcı politikasını izler; şu anda libx264 kullanılır. Donanım kodlayıcı kullanılamıyorsa uygulama otomatik olarak libx264'e döner."
diff --git a/webui/i18n/vi.json b/webui/i18n/vi.json
index afca1497..786b29ca 100644
--- a/webui/i18n/vi.json
+++ b/webui/i18n/vi.json
@@ -308,6 +308,15 @@
"Coverr": "Coverr",
"Coverr API Key": "API Key Coverr ([Lấy API Key](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "Vui lòng nhập **API Key Coverr**",
+ "WaveSpeed AI Video": "Video AI WaveSpeed",
+ "WaveSpeed AI Video Help": "Tạo các đoạn video hoàn toàn mới từ từ khóa kịch bản bằng các mô hình chuyển văn bản thành video của WaveSpeed AI, thay vì tìm kiếm video có sẵn. Việc tạo video được WaveSpeed tính phí theo từng đoạn.",
+ "WaveSpeed API Key": "Khóa API WaveSpeed ([Lấy Khóa API](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "Vui lòng nhập **Khóa API WaveSpeed**",
+ "WaveSpeed Billing Notice": "Mỗi đoạn video được tạo sẽ được WaveSpeed tính phí riêng. Dựa trên thời lượng thuyết minh ước tính và thời lượng mỗi đoạn, dự kiến sẽ tạo khoảng {min}-{max} đoạn. Việc tạo diễn ra theo từng phân đoạn và dừng ngay khi đủ tư liệu.",
+ "WaveSpeed Billing Notice Without Script": "Mỗi đoạn video được tạo sẽ được WaveSpeed tính phí riêng. Nhập hoặc tạo kịch bản video để xem số đoạn ước tính. Việc tạo diễn ra theo từng phân đoạn và dừng ngay khi đủ tư liệu.",
+ "Confirm WaveSpeed Charge": "Tôi hiểu rằng tạo video bằng WaveSpeed là dịch vụ trả phí",
+ "Confirm WaveSpeed Charge Help": "Các đoạn video được tạo theo nhu cầu, từng phân đoạn một; việc tạo dừng khi tư liệu đã đủ cho thời lượng thuyết minh. WaveSpeed tính phí theo từng đoạn được tạo.",
+ "Confirm WaveSpeed Charge Required": "Vui lòng xác nhận chi phí tạo video WaveSpeed trước khi tạo video.",
"Video Encoder": "Bộ Mã Hóa Video",
"Default Video Encoder": "Mặc định (Khuyên dùng)",
"Video Encoder Help": "Tùy chọn nâng cao. Mặc định tuân theo chính sách mã hóa ổn định của ứng dụng, hiện là libx264. Nếu bộ mã hóa phần cứng không khả dụng, ứng dụng tự động chuyển về libx264."
diff --git a/webui/i18n/zh.json b/webui/i18n/zh.json
index 1165ac5f..4c64723a 100644
--- a/webui/i18n/zh.json
+++ b/webui/i18n/zh.json
@@ -326,6 +326,15 @@
"Coverr": "Coverr",
"Coverr API Key": "Coverr API 密钥 ([获取 API Key](https://coverr.co/developers?ctx=header_navigation))",
"Please Enter the Coverr API Key": "请输入 **Coverr API 密钥**",
+ "WaveSpeed AI Video": "WaveSpeed AI 生成",
+ "WaveSpeed AI Video Help": "使用 WaveSpeed AI 文生视频模型按脚本关键词直接生成全新素材,不再搜索库存视频。生成按条计费,由 WaveSpeed 平台结算。",
+ "WaveSpeed API Key": "WaveSpeed API 密钥 ([获取 API Key](https://wavespeed.ai))",
+ "Please Enter the WaveSpeed API Key": "请输入 **WaveSpeed API 密钥**",
+ "WaveSpeed Billing Notice": "每段生成的视频由 WaveSpeed 按条计费。按当前配音时长估算与片段时长计算,预计将生成约 {min}-{max} 段素材。生成按脚本片段逐段进行,凑够所需时长会立即停止。",
+ "WaveSpeed Billing Notice Without Script": "每段生成的视频由 WaveSpeed 按条计费。填写或生成视频文案后可查看预计生成段数。生成按脚本片段逐段进行,凑够所需时长会立即停止。",
+ "Confirm WaveSpeed Charge": "我已了解 WaveSpeed 视频生成为付费服务",
+ "Confirm WaveSpeed Charge Help": "素材按脚本片段逐段按需生成,凑够配音所需时长后立即停止,不会为用不到的片段付费。费用由 WaveSpeed 按实际生成条数结算。",
+ "Confirm WaveSpeed Charge Required": "请确认 WaveSpeed 视频生成费用后再生成视频。",
"Video Encoder": "视频编码器",
"Default Video Encoder": "默认(推荐)",
"Video Encoder Help": "高级选项。“默认”跟随项目的稳定编码策略,当前使用 libx264;选择硬件编码器时,如果当前 FFmpeg、显卡或驱动不可用,会自动回退到 libx264。",