Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

fix(media): 自动探测硬件后端并支持 Linux VAAPI 转码

longmeidao48ea080ec6ae
diff --git a/Dockerfile b/Dockerfile
index 75a8683fe..3a9322d85 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -17,7 +17,7 @@ FROM python:3.14.8-slim-trixie
LABEL org.opencontainers.image.title="Peach" \
org.opencontainers.image.source="https://github.com/peach-mitao/peach" \
org.opencontainers.image.licenses="AGPL-3.0-or-later"
-RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg openssl ca-certificates \
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg openssl ca-certificates mesa-va-drivers vainfo \
&& rm -rf /var/lib/apt/lists/* \
&& groupadd --gid 1000 peach && useradd --uid 1000 --gid 1000 --create-home peach \
&& mkdir /data && chown peach:peach /data
diff --git a/docs/DOCKER.md b/docs/DOCKER.md
index 26c2cb92d..db120128b 100644
--- a/docs/DOCKER.md
+++ b/docs/DOCKER.md
@@ -50,6 +50,35 @@ local = '/media'
容器的网络监听由无桌面入口控制,宿主机绑定地址和端口使用 Compose 的 `PEACH_BIND`、`PEACH_PORT`;`[server]` 的 `host`、`port` 用于直接运行 `peach serve`。独立 Docker 部署保持 `[replication] enabled = false`,无需配置桌面托盘或 SMB 复制。
+## 硬件转码(AMD / Intel VAAPI)
+
+Linux 首次重编码时会探测实际可用的硬件编码器,整片 MP4 与 HLS 分片共享探测结果。AMD / Intel 使用 VAAPI;存在 NVIDIA 设备时探测 NVENC。探测失败的后端在当前服务进程内不再尝试,重启服务后重新探测。封装复制不需要硬件探测。
+
+镜像包含 Debian FFmpeg、Mesa VAAPI 驱动与 `vainfo`。AMD 宿主机需加载 `amdgpu` 和对应固件,并提供 `/dev/dri/renderD*`。Intel 需在自定义镜像内安装适配设备的 VAAPI 驱动;Mesa 驱动不代表已覆盖全部 Intel GPU。将下面的条目合入 Compose 的 `services.peach`,设备路径按宿主机调整:
+
+```yaml
+ devices:
+ - /dev/dri/renderD128:/dev/dri/renderD128
+ group_add:
+ - "${PEACH_RENDER_GID}"
+ environment:
+ PEACH_TRANSCODE_BACKEND: auto
+ PEACH_VAAPI_DEVICE: /dev/dri/renderD128
+```
+
+`PEACH_RENDER_GID` 填宿主机渲染节点所属组的数字 GID。容器以 UID 1000 运行,需要该节点的读写权限;只透传设备但没有组权限仍会初始化失败。Unraid 在容器设置中添加同样的设备映射、环境变量和额外组,无需开启特权模式。默认 Compose 不挂设备,无 GPU 的机器可直接运行。
+
+| 环境变量 | 值与用途 |
+| --- | --- |
+| `PEACH_TRANSCODE_BACKEND` | 默认 `auto`;可设为 `vaapi`、`nvenc` 或 `software`。指定硬件后端仍会验证能否编码,失败回退软件。 |
+| `PEACH_VAAPI_DEVICE` | 指定容器内渲染节点;留空时按名称依次探测 `/dev/dri/renderD*`,使用第一个可用节点。 |
+
+VAAPI 尝试顺序为硬件解码加 `scale_vaapi` / `h264_vaapi`、软件解码加 `hwupload` / `h264_vaapi`、`libx264`。解码能力还受 GPU 型号、片源编码与位深限制;硬件编码可用不能证明每个片源都能硬件解码。NVIDIA 透传还需宿主机驱动及 NVIDIA Container Toolkit,Mesa 不提供 CUDA / NVENC。
+
+出现 CPU 高占用时,先查看日志中的「转码硬件后端」和「转码硬件探测失败」。完成日志「整片转码完成」或「HLS 分片完成」后的 `vaapi` 表示使用硬件解码和编码,`vaapi-encode` 表示软件解码加硬件编码,`libx264` 表示软件转码。再在同一容器、同一用户下检查设备权限与 `vainfo --display drm --device /dev/dri/renderD128` 的结果。`No VA display found` 需结合驱动和设备权限排查,不能仅凭节点存在排除权限问题。
+
+`ffmpeg -hwaccels` 列出构建支持的硬件加速方式,`ffmpeg -h decoder=h264` 等列出对应解码器支持的硬件设备。VAAPI 解码通过普通解码器的硬件加速接口启用,`ffmpeg -decoders` 中没有名为 `vaapi` 的解码器不代表缺少 VAAPI 解码支持。参数含义见 [FFmpeg 官方文档](https://ffmpeg.org/ffmpeg.html#Advanced-Video-options)。目标 GPU 的实际解码、GPU 占用与播放效果需要在部署机器上验证。
+
## 更新与范围
更新镜像并重建容器时保留 `/data`。数据库有待执行迁移时,先备份并按 [运行与配置](OPERATIONS.md) 的迁移流程处理;无桌面入口不会自动迁移已有账本。健康检查使用 `/healthz?ready=1`。
diff --git a/docs/REUSE.md b/docs/REUSE.md
index 2b9b1250d..54c00a329 100644
--- a/docs/REUSE.md
+++ b/docs/REUSE.md
@@ -1,5 +1,11 @@
# 复用清单
+## 硬件转码后端
+
+整片 MP4 与 HLS 复用现有 FFmpeg 的 CUDA / NVENC、VAAPI、`scale_vaapi` 与 `hwupload`,不引入 Python 命令包装库。Windows 发行工具固定为 FFmpeg 9.0.2(GPL-3.0-or-later,来源清单见 `scripts/ffmpeg-sources.json`);Linux 镜像使用 Debian trixie 的 FFmpeg、`mesa-va-drivers` 与 `vainfo`,随 Debian 安全更新取得版本,不另行复制驱动代码。Mesa 按上游各组件许可证分发,驱动增加的镜像体积由构建决定,AMD 需要宿主机 amdgpu 与固件。设备参数和硬件解码接口依据 [FFmpeg 官方文档](https://ffmpeg.org/ffmpeg.html#Advanced-Video-options),驱动范围依据 [Debian VAAPI 说明](https://wiki.debian.org/HardwareVideoAcceleration)。
+
+Peach 只保留设备选择、一次性合成帧探测、命令尝试顺序与失败回退;探测结果由两个服务共享。复用检索覆盖当前 NVENC 链、媒体工具解析器与 Git 历史,没有独立 VAAPI 路径。FFmpeg 已覆盖编解码与滤镜,ffmpeg-python 一类包装层不提供设备驱动或硬件可用性判定,因此沿用项目 subprocess 入口,不新增 Python 依赖。回归用合成输入与进程替身验证 Linux 节点选择、权限和超时、10-bit 转 NV12、整片及分片回退。2026-10-19 的 Windows NVENC 实测使用 640×360 合成帧完成探测,合成 10-bit HEVC 经整片 MP4 与 HLS 两条 CUDA / NVENC 路径输出 H.264 `yuv420p`;128×128 不满足该编码器的最低尺寸,因此探测统一用 640×360。目标 AMD GPU 的驱动初始化、解码与播放验收未取得。无生产入口或真实 ledger 写入。
+
## 独立页面的请求反馈
请求错误文案复用 `core/request-error.ts`,实体登记复用 `core/entity-links.ts`。API 直接引用这两个模块,首启与登录页不加载主界面的路由和字素分段初始化;主界面仍通过 `core/index.ts` 导出同一份错误文案。冷启动导入回归核对 API 不构造界面分段器,既有反馈测试覆盖状态码、超时与服务端中文原因。无新增依赖。
@@ -458,7 +464,7 @@ A 盘垃圾隔离使用短名称 `peach-purge-<32 位 UUID>.peach-quarantine`,
- 缓存型资产路由先问缓存,不先解析源文件:`media_engine.file_for()` 的存在性检查落在 CloudDrive 网盘上一次 137–402 毫秒。`/photo-thumb` 先问 `photo_service.cached()`,`/sample-thumb` 先问 `SampleCache.cached()`,缓存根从 `photo_root` 推出。
- 远程媒体持久缓存复用 HTTPX 0.28.1 的流式响应、Starlette 1.7.0 的文件 Range、filelock 4.0.12 和 `fsutil.atomic_path`;缓存身份、失败保留与按需取得由 Peach 管理。HLS 清单解析用 [m3u8 6.0.0](https://pypi.org/project/m3u8/)(MIT,Python ≥3.7,纯 Python、24.1 KB wheel、无传递依赖),已读取固定版 `model.py` 并验证嵌套清单、密钥、初始化段和字节范围。Hishel 1.4.0(BSD-3-Clause)已读取 `_sync_cache.py` 与 Range 判据,通用 HTTP 缓存按来源 URL、缓存头和重新验证工作;此处需按稳定条目身份避开签名 URL 更新、永久保留成功媒体,因此复用现有持久文件路径。规则及验收见 [媒体缓存](MEDIA_CACHE.md)。
- 账本路径在 Windows 只做 `abspath`,不 `resolve()`:PikPak 的 A: 是 WinFsp 网络驱动器,`resolve()` 得到 UNC 形态,之后每个经 `file_for()` 的播放请求都慢几个数量级;115 的 B: 不受影响。
-- 不兼容片源(HEVC、mp3 以外的音轨、非 MP4 容器)按 6 秒片重编码给 HLS,账本没记时长或为负时用 ffprobe 的时长切,探测也拿不到才回 Range。分片重编码链与整片转码相同(CUDA 解码加 NVENC、软件解码加 NVENC、libx264),同一分片只起一个 FFmpeg。Range 响应按 1 MiB 读文件,`BufferedFileResponse` 自己盯 `http.disconnect`(uvicorn 断开后 `send()` 静默返回,Starlette `FileResponse` 不监听),否则拖一次进度条就留下一个把整部片拉完的幽灵读者。
+- 不兼容片源(HEVC、mp3 以外的音轨、非 MP4 容器)按 6 秒片重编码给 HLS,账本没记时长或为负时用 ffprobe 的时长切,探测也拿不到才回 Range。分片与整片共享硬件后端探测及回退链,见[硬件转码后端](#硬件转码后端),同一分片只起一个 FFmpeg。Range 响应按 1 MiB 读文件,`BufferedFileResponse` 自己盯 `http.disconnect`(uvicorn 断开后 `send()` 静默返回,Starlette `FileResponse` 不监听),否则拖一次进度条就留下一个把整部片拉完的幽灵读者。
- 有 B 帧却没有 `ctts` 的 MP4 是时间戳错乱,浏览器丢掉倒着走的帧。这类片源不重编码:`mp4repair.py` 重建一份 `moov`(游程编码的 `ctts`、编辑列表补整体平移、`stco`/`co64` 按头长差平移)存成 `transcode_root` 里的 `.mp4hdr` 边车,`/stream` 用「边车的头 + 原文件那段 mdat」按 Range 发。显示顺序取自 `ffprobe -ignore_editlist 1 -show_entries frame=pts`,`pkt_dts` 不能用。边车算出来前走 HLS 转码,同一部片后台只算一次,算不出就跳过。
- 「只采集在线资料」对齐全的行(番号已落库、字段有着落或已在候选表、封面在位)不碰磁盘;文件在不在看目录列表、同目录只列一次,扫描用目录列表自带的大小与时间、不逐个 stat;候选 CSV 每 5 秒写盘一次,被打断也在收尾写全。
- 一个控件在两页出现时,选中态也归它:首页、资料页与关注页的「全部/没看过/稍后看/已标记」共用 `use-view-glide.ts` 那块滑动玻璃与 `[data-view-glide]`,填充只由玻璃给,各排自己不铺底。
@@ -544,7 +550,7 @@ A 盘垃圾隔离使用短名称 `peach-purge-<32 位 UUID>.peach-quarantine`,
| 已确认厂牌的目录归位 | Javinizer-Go v1.5.2 organizer(MIT)只作冲突预检、模板化目录和回滚边界的协议参考,不调用它,不让它持有 Peach ledger | `rehome_unknown_jav.py` 只消费人工确认映射;先出逐文件 CSV,拒绝扁平化重名与厂牌冲突,SQLite 备份后移动文件并同步 Peach 路径/实体 provenance |
| FC2 目录元数据与跨号证据 | 已缓存的 fc2cmadb Inertia `article`/评论;Javinizer-Go v1.5.2 的 FC2 解析器(MIT)只作商品页字段边界参考 | 旧文章仍有标题、原始标签、日期、时长、卖家、FC2 CDN 封面与 `comments`(2026-08-31 登录态实测);无歧义标签译成现有词表,标题/标签进 `/review`,`w1200` 封面过尺寸与解码门槛落生成产物;pair、合集/分片保护、hash/时长/尺寸佐证、库外 evidence、健康统计与复核归 Peach,不依赖 FC2-Leak-Detector/JavSP,镜像候选不直写 ledger |
| 缺索引 MP4 重建 | untrunc(anthwlock `9d86ec9`,GPL-2.0-or-later)与兼容的 FFmpeg 8.1.3 静态构建,固定来源及哈希见 `scripts/untrunc-sources.json`。Windows 安装包与免安装包携带 `tools/untrunc`,同一 Release 提供完整对应源码;原生样片实测覆盖尾部 `moov` 缺失后的 H.264/AAC 恢复、时长与全片解码。显式 `PEACH_UNTRUNC` 优先,其后依次查随包目录、数据工具与 PATH | `src/peach/mp4recover.py` 挑参照(同目录文件名最近的先试,最多 4 部)、验收(解码错误 ≤3 行、音视频时长差 ≤5%)、换回原路径并把坏原件改名成同目录的 `.文件名.peach-original`;缺整个 `moov` 的片子哪里都打不开,所以结果替换原文件,不像缺 `ctts` 那样另存头。实测见 [取证](SOURCING.md#媒体与关注实测) |
-| 媒体探测/转码 | Windows 独立包从固定源码交叉编译 FFmpeg 9.0.2、x264 与 nv-codec-headers,按 GPL-3.0-or-later 分发;版本、来源和哈希见 `scripts/ffmpeg-sources.json`。工具与完整对应源码一起构建,安装包和免安装 ZIP 共用经校验的 `tools/ffmpeg`。源码与 CI 媒体测试仍可使用 PATH 工具([取证](SOURCING.md#依赖与工具实测)) | 容器与编码分别检查:MP4/M4V 的 H.264 8-bit 加兼容音轨直出,其余容器里的 H.264 8-bit 只换 MP4 封装;其余 Windows 输入依次 CUDA→NVENC、软件解码→NVENC、`libx264`,macOS 封装复制或软件转码 |
+| 媒体探测/转码 | Windows 独立包从固定源码交叉编译 FFmpeg 9.0.2、x264 与 nv-codec-headers,按 GPL-3.0-or-later 分发;版本、来源和哈希见 `scripts/ffmpeg-sources.json`。工具与完整对应源码一起构建,安装包和免安装 ZIP 共用经校验的 `tools/ffmpeg`。源码与 CI 媒体测试仍可使用 PATH 工具([取证](SOURCING.md#依赖与工具实测)) | 容器与编码分别检查:MP4/M4V 的 H.264 8-bit 加兼容音轨直出,其余容器里的 H.264 8-bit 只换 MP4 封装;重编码按[硬件转码后端](#硬件转码后端)选择,macOS 默认软件转码 |
| HTML5/HLS/DASH 播放 | Video.js 10.1.0 的 `@videojs/html`、`@videojs/hlsjs-video` 与 `@videojs/dash-video`,通过官方 `@videojs/cdn` 本地固定模块分发(Apache-2.0) | 流方案、授权、稳定时长、回退顺序和统计面板;详情不兼容片源复用 HlsSegmentService 与 FFmpeg 按六秒编码 H.264/AAC,独立缓存、绝对时间轴及会话取消,无整片预转码 |
| 播放器设置与影院布局 | Video.js 10.1.0 的播放器状态、原生媒体事件、播放/静音/全屏/画中画按钮与进度/音量滑条;YouTube `e937390a` 实际 DOM/CSS/JS 给几何、状态、动画和图形证据 | Peach 皮肤组合氛围模式、倍速、真实清晰度和影院模式:59 px 两排控制栏、40→111 px 横向音量、4→6 px 进度、右侧共享胶囊、整行悬停的 274 px 设置菜单、视口级全屏;普通视图 `contain`,全屏 `cover`。播放会话与同一枚原生视频经过舞台和小窗整体搬移,状态、字幕与上报保留;设置、时间、预览、统计、字幕菜单、中央提示和错误反馈属于 Peach。皮肤沿用本地 SVG 与 spinner,不复制上游按钮、滑条或媒体引擎的控制逻辑 |
| 播放器时刻预览 | Video.js 原生进度控件 + Peach 的 `/timeline?id=&s=`(10×10 接触印相),取不到时退到 `/poster?id=&c=0…8` 九宫格切片 | `peach.timeline_sheets` 按每 10 或 30 秒一帧预铺,只覆盖 `location='local'`(网盘每抽一帧都回源,[流量实测](SOURCING.md#媒体与关注实测));其余退回只给近似时刻的九宫格。抽帧与拼图共用 `peach.frame_capture`。`videojs-vtt-thumbnails`/`videojs-sprite-thumbnails` 要另建 sprite/VTT 契约与运行时依赖,格子换算在 Peach 是一行整除,不引入 |
diff --git a/scripts/smoke_docker.py b/scripts/smoke_docker.py
index a1ced8a9a..93e0a3591 100644
--- a/scripts/smoke_docker.py
+++ b/scripts/smoke_docker.py
@@ -51,6 +51,38 @@ def ready(name: str) -> None:
raise RuntimeError("容器未就绪:" + docker("logs", name))
+def transcode_checks(name: str) -> None:
+ """无 GPU 的容器核对 VAAPI 软件栈与应用的整片、分片软件回退。"""
+ assert "vaapi" in docker("exec", name, "ffmpeg", "-hide_banner", "-hwaccels")
+ assert "h264_vaapi" in docker("exec", name, "ffmpeg", "-hide_banner", "-encoders")
+ assert "scale_vaapi" in docker("exec", name, "ffmpeg", "-hide_banner", "-filters")
+ assert "vaapi" in docker("exec", name, "ffmpeg", "-hide_banner", "-h", "decoder=h264")
+ docker("exec", name, "python", "-c",
+ "import ctypes; from pathlib import Path; "
+ "drivers=list(Path('/usr/lib').glob('*/dri/radeonsi_drv_video.so')); "
+ "assert drivers, '缺少 AMD VAAPI 驱动'; ctypes.CDLL(str(drivers[0]))")
+ docker("exec", name, "ffmpeg", "-v", "error", "-i", "/data/smoke-media/fixture.mp4",
+ "-c:v", "mpeg4", "/data/smoke-media/transcode.mkv")
+ docker("exec", name, "python", "-c",
+ "import asyncio; from pathlib import Path; from peach.ffmpeg import FFmpegResolver; "
+ "from peach.transcodes import TranscodeService; from peach.segments import HlsSegmentService; "
+ "from peach.streaming import StreamSessionRegistry; "
+ "root=Path('/data/smoke-media'); resolver=FFmpegResolver(root/'tools'); "
+ "whole=TranscodeService(resolver,root/'mp4-cache'); "
+ "assert not whole.hardware.encoders(resolver.ffmpeg().path), '验收容器应未透传 GPU'; "
+ "source=root/'transcode.mkv'; target,converted=whole.browser_path(95,source); "
+ "assert converted and target.stat().st_size; target.rename(root/'converted.mp4'); "
+ "hls=HlsSegmentService(resolver,root/'hls-cache',hardware=whole.hardware); "
+ "segment=asyncio.run(hls.generate(source,0,1,asset_id=95,index=0,session='smoke',"
+ "registry=StreamSessionRegistry(),transcode=True)); "
+ "assert segment.stat().st_size; segment.rename(root/'converted.ts')")
+ for filename in ("converted.mp4", "converted.ts"):
+ report = json.loads(docker("exec", name, "ffprobe", "-v", "error", "-select_streams", "v:0",
+ "-show_entries", "stream=codec_name,pix_fmt", "-of", "json",
+ "/data/smoke-media/" + filename))
+ assert report["streams"][0] == {"codec_name": "h264", "pix_fmt": "yuv420p"}, report
+
+
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("image")
@@ -89,6 +121,7 @@ def main() -> None:
assert asset is not None, "资料处理请求未登记测试视频"
media = json.loads(request(name, f"/stream?id={asset}", headers={"Range": "bytes=0-63"}))
assert media == {"status": 206, "size": 64}, media
+ transcode_checks(name)
config_path = "/data/config.toml"
original = docker("exec", name, "cat", config_path)
docker("exec", name, "python", "-c",
@@ -106,7 +139,8 @@ def main() -> None:
ready(name)
assert docker("exec", name, "cat", config_path) == original
print(json.dumps({"image": args.image, "checks": ["non-root", "ready", "auth", "configuration",
- "scan", "range", "reload", "restart", "persistence"]}))
+ "scan", "range", "vaapi-stack", "transcode-fallback",
+ "reload", "restart", "persistence"]}))
finally:
docker("rm", "--force", name, check=False)
docker("volume", "rm", volume, check=False)
diff --git a/scripts/test_runner.py b/scripts/test_runner.py
index 3414f1016..5bb2247dd 100644
--- a/scripts/test_runner.py
+++ b/scripts/test_runner.py
@@ -67,7 +67,7 @@ SCOPES: dict[str, tuple[str, ...]] = {
"test_mp4recover.py", "test_web_media_repair.py",
"test_previews.py", "test_preview_transport.py",
"test_providers.py", "test_segments.py", "test_streaming.py",
- "test_subtitles.py", "test_transcodes.py", "test_strm.py",
+ "test_subtitles.py", "test_transcodes.py", "test_hardware_transcode.py", "test_strm.py",
"test_guangya_sources.py", "test_media_sources.py"),
"sync": ("test_sync*.py", "test_platform.py", "test_mount.py", "test_tray*.py", "test_log_retention.py",
"test_mdns.py", "test_netwatch.py", "test_certs.py",
@@ -266,6 +266,7 @@ AUTO_SCOPE_FILES: dict[str, tuple[str, ...]] = {
# tooling 里的脚本策略门槛验它的形态。
AUTO_SCOPE_PREFIXES: tuple[tuple[str, str | tuple[str, ...]], ...] = (
("src/peach/media.py", "media"),
+ ("src/peach/hardware_transcode.py", "media"),
# 关键帧与 ctts 都从 moov 读,测试住在 `test_segments.py` 里。
("src/peach/mp4index.py", "media"),
("src/peach/mp4repair.py", "media"),
diff --git a/src/peach/api.py b/src/peach/api.py
index 2b4b6bbb2..6b35903d6 100644
--- a/src/peach/api.py
+++ b/src/peach/api.py
@@ -270,6 +270,7 @@ def create_app(
)
hls_service = HlsSegmentService(
resolver, settings.stream_root, prefer_hardware=transcode_service.prefer_hardware,
+ hardware=transcode_service.hardware,
)
mdns = create_mdns_publisher(
settings.mdns_name, settings.mdns_port, secure=settings.tls_enabled,
diff --git a/src/peach/hardware_transcode.py b/src/peach/hardware_transcode.py
new file mode 100644
index 000000000..1983036b9
--- /dev/null
+++ b/src/peach/hardware_transcode.py
@@ -0,0 +1,114 @@
+"""用合成画面探测 FFmpeg 硬件编码,共享整片与分片的尝试链。"""
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import sys
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+CUDA_DECODE_CODECS = frozenset({"h264", "hevc", "vp9", "av1"})
+PROBE_TIMEOUT_SECONDS = 10
+
+
+@dataclass(frozen=True)
+class HardwareAttempt:
+ name: str
+ before_input: tuple[str, ...]
+ output: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class HardwareEncoder:
+ backend: str
+ device: str = ""
+
+ def attempts(self, codec: str) -> tuple[HardwareAttempt, ...]:
+ if self.backend == "nvenc":
+ output = ("-c:v", "h264_nvenc", "-preset", "p1", "-tune", "hq",
+ "-rc", "vbr", "-cq", "21", "-b:v", "0")
+ software_decode = HardwareAttempt("nvenc", (), output + ("-pix_fmt", "yuv420p"))
+ if codec not in CUDA_DECODE_CODECS:
+ return (software_decode,)
+ return (HardwareAttempt(
+ "cuda-nvenc", ("-hwaccel", "cuda", "-hwaccel_output_format", "cuda"),
+ ("-vf", "scale_cuda=format=nv12") + output,
+ ), software_decode)
+ device = ("-vaapi_device", self.device)
+ output = ("-c:v", "h264_vaapi", "-qp", "21")
+ return (
+ HardwareAttempt(
+ "vaapi", device + ("-hwaccel", "vaapi", "-hwaccel_device", self.device,
+ "-hwaccel_output_format", "vaapi"),
+ ("-vf", "scale_vaapi=format=nv12") + output,
+ ),
+ HardwareAttempt("vaapi-encode", device,
+ ("-vf", "format=nv12,hwupload") + output),
+ )
+
+
+class HardwareTranscoder:
+ """首次重编码时探测,结果按 FFmpeg 路径缓存;不读取媒体或写入缓存文件。"""
+
+ def __init__(self, *, enabled: bool = True):
+ self.enabled = enabled
+ self.backend = os.environ.get("PEACH_TRANSCODE_BACKEND", "auto").strip().lower()
+ if self.backend not in {"auto", "software", "nvenc", "vaapi"}:
+ raise ValueError("PEACH_TRANSCODE_BACKEND 必须为 auto、software、nvenc 或 vaapi")
+ self.device = os.environ.get("PEACH_VAAPI_DEVICE", "").strip()
+ self._encoders: dict[Path, tuple[HardwareEncoder, ...]] = {}
+ self._lock = threading.Lock()
+
+ def _candidates(self) -> tuple[HardwareEncoder, ...]:
+ candidates = []
+ if self.backend == "nvenc" or (self.backend == "auto" and (
+ sys.platform == "win32" or Path("/dev/nvidia0").exists()
+ or Path("/proc/driver/nvidia/version").exists()
+ )):
+ candidates.append(HardwareEncoder("nvenc"))
+ if self.backend == "vaapi" or (self.backend == "auto" and sys.platform.startswith("linux")):
+ devices = [self.device] if self.device else sorted(p.as_posix() for p in Path("/dev/dri").glob("renderD*"))
+ candidates.extend(HardwareEncoder("vaapi", device) for device in devices)
+ return tuple(candidates)
+
+ def encoders(self, ffmpeg: Path) -> tuple[HardwareEncoder, ...]:
+ if not self.enabled or self.backend == "software":
+ return ()
+ with self._lock:
+ if ffmpeg not in self._encoders:
+ available = []
+ for encoder in self._candidates():
+ if self._probe(ffmpeg, encoder):
+ available.append(encoder)
+ # 一个可用 VAAPI 节点足以服务这条链,避免重复尝试同类设备。
+ if encoder.backend == "vaapi":
+ break
+ self._encoders[ffmpeg] = tuple(available)
+ logger.info("转码硬件后端:%s", ", ".join(
+ item.backend + (f" ({item.device})" if item.device else "")
+ for item in available) or "software")
+ return self._encoders[ffmpeg]
+
+ @staticmethod
+ def _probe(ffmpeg: Path, encoder: HardwareEncoder) -> bool:
+ # 用软件生成一帧,再验证设备初始化、上传与 H.264 硬件编码。
+ attempt = encoder.attempts("")[-1]
+ command = (str(ffmpeg), "-hide_banner", "-loglevel", "error", "-nostdin",
+ *attempt.before_input, "-f", "lavfi", "-i", "color=size=640x360:rate=1",
+ "-frames:v", "1", *attempt.output, "-f", "null", "-")
+ try:
+ result = subprocess.run(
+ command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+ stderr=subprocess.PIPE, timeout=PROBE_TIMEOUT_SECONDS,
+ creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
+ )
+ except (OSError, subprocess.SubprocessError) as exc:
+ logger.warning("转码硬件探测失败 %s %s:%s", encoder.backend, encoder.device, exc)
+ return False
+ if result.returncode:
+ logger.warning("转码硬件探测失败 %s %s:%s", encoder.backend, encoder.device,
+ result.stderr.decode("utf-8", "replace")[-1000:])
+ return result.returncode == 0
diff --git a/src/peach/segments.py b/src/peach/segments.py
index 517a16cde..0b95431f8 100644
--- a/src/peach/segments.py
+++ b/src/peach/segments.py
@@ -2,6 +2,7 @@
from __future__ import annotations
import asyncio
+import logging
import math
import os
import subprocess
@@ -10,6 +11,7 @@ from collections import OrderedDict
from pathlib import Path
from .ffmpeg import FFmpegResolver
+from .hardware_transcode import HardwareTranscoder
from .mp4index import keyframe_seconds, segment_plan
from .streaming import StreamSessionRegistry
@@ -17,10 +19,9 @@ HLS_SEGMENT_SECONDS = 6
# 片段缓存上限。超了按最后访问时间淘汰;片段可再生,丢了只是重跑一次 FFmpeg。
DEFAULT_CACHE_BYTES = 2 << 30
PLAN_CACHE_LIMIT = 256
-#: 交给 NVDEC 解码的编码。
-CUDA_DECODE_CODECS = frozenset({"h264", "hevc", "vp9", "av1"})
CODEC_CACHE_LIMIT = 256
PROBE_TIMEOUT_SECONDS = 20
+logger = logging.getLogger(__name__)
def _probe_video_codec(ffprobe: Path, source: Path) -> str:
@@ -74,13 +75,14 @@ class HlsSegmentService:
max_concurrent: int | None = None,
cache_bytes: int = DEFAULT_CACHE_BYTES,
prefer_hardware: bool = False,
+ hardware: HardwareTranscoder | None = None,
):
self.resolver = resolver
self.work_root = work_root
self.segment_seconds = segment_seconds
self.cache_bytes = cache_bytes
- # 重编码的分片先试 NVENC,失败再退回 libx264;与整片转码用同一个偏好。
self.prefer_hardware = prefer_hardware
+ self.hardware = hardware if hardware is not None else HardwareTranscoder(enabled=prefer_hardware)
# 每个分片请求都会起一个 FFmpeg;播放器本身就并发预取,多设备同看能把机器打满。
self._limit = max_concurrent or max(1, (os.cpu_count() or 4) // 2)
self._semaphore: asyncio.Semaphore | None = None
@@ -209,15 +211,19 @@ class HlsSegmentService:
if registry.is_cancelled(session):
raise SegmentCancelled(session)
target.parent.mkdir(parents=True, exist_ok=True)
- codec = await self.video_codec(source) if transcode and self.prefer_hardware else ""
+ codec = await self.video_codec(source) if transcode and self.hardware.enabled else ""
detail = ""
async with self._gate():
- for name, build in self._attempts(choice.path, source, start, duration, transcode, codec):
+ attempts = await asyncio.to_thread(
+ self._attempts, choice.path, source, start, duration, transcode, codec,
+ )
+ for name, build in attempts:
temporary = target.with_name(f"{uuid.uuid4().hex}.tmp.ts")
try:
returncode, stderr = await self._run(build(temporary), session, registry)
if returncode == 0 and temporary.is_file() and temporary.stat().st_size:
temporary.replace(target)
+ logger.info("HLS 分片完成:%s", name)
self._evict()
return target
if registry.is_cancelled(session):
@@ -241,8 +247,7 @@ class HlsSegmentService:
transcode: bool, codec: str = ""):
"""依次尝试的命令,每项是 (名字, 接收临时文件路径的构造函数)。
- 封装复制只有一种。重编码与整片转码用同一条链:CUDA 解码加 NVENC、软件解码加 NVENC、
- 最后 libx264;没有显卡的机器只是多失败两次,不会没有分片。
+ 封装复制只有一种。重编码与整片转码共享可用硬件后端,最后回退 libx264。
NVDEC 解得出来的编码才走 CUDA 解码,`codec` 空或不在名单里就从软件解码起。
判据要在开跑前定,因为坏结果不会自报:实测 `MIAD573_02.wmv`(vc1、1080p)经
@@ -263,15 +268,12 @@ class HlsSegmentService:
return [("copy", lambda out: prefix + window + mapping + ["-c", "copy", "-copyts"] + mux + [str(out)])]
window = ["-ss", f"{start:.3f}", "-i", str(source), "-t", f"{duration:.3f}"]
audio = ["-c:a", "aac", "-b:a", "160k", "-output_ts_offset", f"{start:.3f}"]
- nvenc = ["-c:v", "h264_nvenc", "-preset", "p1", "-tune", "hq", "-rc", "vbr", "-cq", "21", "-b:v", "0"]
attempts = []
- if self.prefer_hardware:
- if codec in CUDA_DECODE_CODECS:
- cuda = ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"]
- attempts.append(("cuda-nvenc", lambda out: prefix + cuda + window + mapping
- + ["-vf", "scale_cuda=format=nv12"] + nvenc + audio + mux + [str(out)]))
- attempts.append(("nvenc", lambda out: prefix + window + mapping
- + nvenc + ["-pix_fmt", "yuv420p"] + audio + mux + [str(out)]))
+ for encoder in self.hardware.encoders(ffmpeg):
+ for attempt in encoder.attempts(codec):
+ attempts.append((attempt.name, lambda out, attempt=attempt:
+ prefix + list(attempt.before_input) + window + mapping
+ + list(attempt.output) + audio + mux + [str(out)]))
attempts.append(("libx264", lambda out: prefix + window + mapping + [
"-c:v", "libx264", "-preset", "veryfast", "-crf", "21", "-pix_fmt", "yuv420p", "-threads", "2",
] + audio + mux + [str(out)]))
diff --git a/src/peach/transcodes.py b/src/peach/transcodes.py
index dc54e5c97..ac59ef424 100644
--- a/src/peach/transcodes.py
+++ b/src/peach/transcodes.py
@@ -1,6 +1,7 @@
from __future__ import annotations
import json
+import logging
import os
import subprocess
import threading
@@ -11,6 +12,7 @@ from dataclasses import dataclass, replace
from pathlib import Path
from .ffmpeg import FFmpegResolver
+from .hardware_transcode import HardwareTranscoder
from .mp4index import composition_offsets_present
@@ -18,6 +20,7 @@ BROWSER_NATIVE_SUFFIXES = frozenset({".mp4", ".m4v", ".webm", ".ogv", ".ogg"})
DIRECT_MP4_PIXEL_FORMATS = frozenset({"yuv420p", "yuvj420p"})
TRANSCODE_TIMEOUT_SECONDS = 3600
PROBE_TIMEOUT_SECONDS = 20
+logger = logging.getLogger(__name__)
@dataclass(frozen=True)
@@ -58,9 +61,8 @@ class TranscodeService:
):
self.resolver = resolver
self.cache_root = cache_root
- # 当前生产机是 NVIDIA Windows。macOS 走软件编码,避免每次先跑两次
- # 必然失败的 CUDA/NVENC 命令;测试和后续平台适配可显式覆盖。
- self.prefer_hardware = os.name == "nt" if prefer_hardware is None else prefer_hardware
+ self.prefer_hardware = prefer_hardware is not False
+ self.hardware = HardwareTranscoder(enabled=self.prefer_hardware)
self._locks: dict[int, list] = {}
self._locks_guard = threading.Lock()
self._slots = threading.Semaphore(max(1, max_concurrent))
@@ -179,6 +181,7 @@ class TranscodeService:
if (returncode == 0 and temporary.is_file()
and temporary.stat().st_size):
temporary.replace(target)
+ logger.info("整片转码完成:%s", attempt.name)
completed = True
break
detail = (stderr or b"").decode("utf-8", "replace")[-1000:]
@@ -293,13 +296,12 @@ class TranscodeService:
source: Path,
temporary: Path,
profile: _MediaProfile | None,
- ) -> tuple[_TranscodeAttempt, ...]:
+ ):
prefix = (
str(ffmpeg), "-hide_banner", "-loglevel", "error", "-nostdin", "-y",
)
mapping = ("-map", "0:v:0", "-map", "0:a:0?", "-sn", "-dn")
finish = ("-movflags", "+faststart", str(temporary))
- attempts: list[_TranscodeAttempt] = []
if (profile is not None and profile.video_codec == "h264"
and profile.pixel_format in DIRECT_MP4_PIXEL_FORMATS):
@@ -308,47 +310,30 @@ class TranscodeService:
if profile.audio_codec in {"", "aac"}
else ("-c:a", "aac", "-b:a", "160k")
)
- attempts.append(_TranscodeAttempt(
+ yield _TranscodeAttempt(
"video-copy",
prefix + ("-i", str(source)) + mapping + ("-c:v", "copy") + audio + finish,
- ))
+ )
fast_audio = (
("-c:a", "copy")
if profile is not None and profile.audio_codec in {"", "aac"}
else ("-c:a", "aac", "-b:a", "160k")
)
- nvenc = (
- "-c:v", "h264_nvenc", "-preset", "p1", "-tune", "hq",
- "-rc", "vbr", "-cq", "21", "-b:v", "0",
- )
- if self.prefer_hardware:
- # CUDA surfaces stay on the GPU; scale_cuda also converts common 10-bit HEVC
- # inputs to NV12 so H.264 NVENC does not have to fall back to a CPU transfer.
- attempts.append(_TranscodeAttempt(
- "cuda-nvenc",
- prefix + (
- "-hwaccel", "cuda", "-hwaccel_output_format", "cuda",
- "-i", str(source),
- ) + mapping + ("-vf", "scale_cuda=format=nv12") + nvenc + fast_audio + finish,
- ))
- # Some codecs have no NVDEC path but can still keep the expensive encode on NVENC.
- attempts.append(_TranscodeAttempt(
- "nvenc",
- prefix + ("-i", str(source)) + mapping + nvenc + (
- "-pix_fmt", "yuv420p",
- ) + fast_audio + finish,
- ))
-
- # Final compatibility path: preserve the previous encoder and always normalize audio.
- attempts.append(_TranscodeAttempt(
+ for encoder in self.hardware.encoders(ffmpeg):
+ for attempt in encoder.attempts(profile.video_codec if profile else ""):
+ yield _TranscodeAttempt(
+ attempt.name, prefix + attempt.before_input + ("-i", str(source))
+ + mapping + attempt.output + fast_audio + finish,
+ )
+
+ yield _TranscodeAttempt(
"libx264",
prefix + ("-i", str(source)) + mapping + (
"-c:v", "libx264", "-preset", "veryfast", "-crf", "21",
"-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "160k",
) + finish,
- ))
- return tuple(attempts)
+ )
def _execute(
self,
diff --git a/tests/test_hardware_transcode.py b/tests/test_hardware_transcode.py
new file mode 100644
index 000000000..2d3376257
--- /dev/null
+++ b/tests/test_hardware_transcode.py
@@ -0,0 +1,182 @@
+"""硬件后端探测与整片、HLS 转码的失败回退。"""
+import asyncio
+import os
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from peach.ffmpeg import BinaryChoice
+from peach.hardware_transcode import HardwareEncoder, HardwareTranscoder
+from peach.segments import HlsSegmentService
+from peach.streaming import StreamSessionRegistry
+from peach.transcodes import TranscodeService, _MediaProfile
+
+
+class HardwareDetectionTests(unittest.TestCase):
+ def setUp(self):
+ environment = patch.dict(os.environ, {"PEACH_TRANSCODE_BACKEND": "auto", "PEACH_VAAPI_DEVICE": ""})
+ environment.start()
+ self.addCleanup(environment.stop)
+
+ def test_linux_render_nodes_are_tried_until_one_encodes(self):
+ commands = []
+
+ def run(command, **kwargs):
+ commands.append(command)
+ self.assertEqual(kwargs["timeout"], 10)
+ device = command[command.index("-vaapi_device") + 1]
+ return subprocess.CompletedProcess(command, int(device.endswith("128")), stderr=b"no display")
+
+ hardware = HardwareTranscoder()
+ with patch("peach.hardware_transcode.sys.platform", "linux"), \
+ patch.object(Path, "exists", return_value=False), \
+ patch.object(Path, "glob", return_value=[Path("/dev/dri/renderD128"), Path("/dev/dri/renderD129")]), \
+ patch("peach.hardware_transcode.subprocess.run", side_effect=run):
+ encoders = hardware.encoders(Path("ffmpeg"))
+ self.assertEqual(encoders, (HardwareEncoder("vaapi", "/dev/dri/renderD129"),))
+ self.assertEqual(hardware.encoders(Path("ffmpeg")), encoders)
+ self.assertEqual(len(commands), 2)
+ self.assertTrue(all("h264_vaapi" in command for command in commands))
+ self.assertTrue(all("format=nv12,hwupload" in command for command in commands))
+ self.assertTrue(all(command[-2:] == ("null", "-") for command in commands))
+
+ def test_explicit_device_and_backend_are_probed_without_gpu_listing(self):
+ with patch.dict(os.environ, {"PEACH_TRANSCODE_BACKEND": "vaapi", "PEACH_VAAPI_DEVICE": "/dev/dri/renderD130"}):
+ hardware = HardwareTranscoder()
+ with patch("peach.hardware_transcode.subprocess.run", return_value=Mock(returncode=0)) as run:
+ self.assertEqual(hardware.encoders(Path("ffmpeg")), (HardwareEncoder("vaapi", "/dev/dri/renderD130"),))
+ self.assertIn("/dev/dri/renderD130", run.call_args.args[0])
+ self.assertNotIn("h264_nvenc", run.call_args.args[0])
+
+ def test_probe_errors_and_timeouts_are_cached_as_unavailable(self):
+ for failure in (PermissionError("denied"), subprocess.TimeoutExpired("ffmpeg", 10)):
+ with self.subTest(failure=failure), patch.dict(os.environ, {"PEACH_TRANSCODE_BACKEND": "nvenc"}):
+ hardware = HardwareTranscoder()
+ with patch("peach.hardware_transcode.subprocess.run", side_effect=failure) as run:
+ self.assertEqual(hardware.encoders(Path("ffmpeg")), ())
+ self.assertEqual(hardware.encoders(Path("ffmpeg")), ())
+ self.assertEqual(run.call_count, 1)
+
+ def test_software_mode_and_disabled_preference_do_not_probe(self):
+ for enabled, backend in ((True, "software"), (False, "auto")):
+ with self.subTest(enabled=enabled, backend=backend), \
+ patch.dict(os.environ, {"PEACH_TRANSCODE_BACKEND": backend}), \
+ patch("peach.hardware_transcode.subprocess.run") as run:
+ self.assertEqual(HardwareTranscoder(enabled=enabled).encoders(Path("ffmpeg")), ())
+ run.assert_not_called()
+
+ def test_linux_without_devices_and_macos_have_no_automatic_candidates(self):
+ for platform in ("linux", "darwin"):
+ with self.subTest(platform=platform), patch("peach.hardware_transcode.sys.platform", platform), \
+ patch.object(Path, "exists", return_value=False), patch.object(Path, "glob", return_value=[]):
+ self.assertEqual(HardwareTranscoder()._candidates(), ())
+
+ def test_linux_nvidia_device_enables_nvenc_probe(self):
+ with patch("peach.hardware_transcode.sys.platform", "linux"), \
+ patch.object(Path, "exists", return_value=True), patch.object(Path, "glob", return_value=[]), \
+ patch("peach.hardware_transcode.subprocess.run", return_value=Mock(returncode=0)) as run:
+ self.assertEqual(HardwareTranscoder().encoders(Path("ffmpeg")), (HardwareEncoder("nvenc"),))
+ self.assertIn("h264_nvenc", run.call_args.args[0])
+
+ def test_invalid_backend_has_an_actionable_error(self):
+ with patch.dict(os.environ, {"PEACH_TRANSCODE_BACKEND": "typo"}):
+ with self.assertRaisesRegex(ValueError, "PEACH_TRANSCODE_BACKEND"):
+ HardwareTranscoder()
+
+
+class VaapiConsumerTests(unittest.TestCase):
+ def setUp(self):
+ self.tmp = tempfile.TemporaryDirectory()
+ self.addCleanup(self.tmp.cleanup)
+ self.root = Path(self.tmp.name).resolve()
+ self.source = self.root / "clip.mkv"
+ self.source.write_bytes(b"source")
+ self.resolver = Mock(ffmpeg=lambda: BinaryChoice(Path("ffmpeg"), "test"), ffprobe=lambda: None)
+ environment = patch.dict(os.environ, {"PEACH_TRANSCODE_BACKEND": "vaapi", "PEACH_VAAPI_DEVICE": "/dev/dri/renderD128"})
+ environment.start()
+ self.addCleanup(environment.stop)
+ probe = patch.object(HardwareTranscoder, "_probe", return_value=True)
+ probe.start()
+ self.addCleanup(probe.stop)
+
+ def test_full_file_tries_vaapi_then_hardware_encode_then_software(self):
+ for failures, expected in ((0, ["vaapi"]), (1, ["vaapi", "vaapi-encode"]),
+ (2, ["vaapi", "vaapi-encode", "libx264"])):
+ with self.subTest(failures=failures):
+ service = TranscodeService(self.resolver, self.root / f"cache{failures}")
+ captured = []
+
+ def execute(command, *, captured=captured, failures=failures, **kwargs):
+ captured.append((kwargs["label"], command))
+ if len(captured) <= failures:
+ return 1, b"", b"hardware failed"
+ Path(command[-1]).write_bytes(b"mp4")
+ return 0, b"", b""
+
+ profile = _MediaProfile("hevc", "yuv420p10le", "aac")
+ with patch.object(service, "_probe", return_value=profile), \
+ patch.object(service, "_execute", side_effect=execute):
+ target, converted = service.browser_path(95, self.source)
+ self.assertTrue(converted)
+ self.assertEqual(target.read_bytes(), b"mp4")
+ self.assertEqual([name for name, _ in captured], expected)
+ command = captured[0][1]
+ self.assertLess(command.index("-hwaccel"), command.index("-i"))
+ self.assertIn("scale_vaapi=format=nv12", command)
+ self.assertIn("h264_vaapi", command)
+ self.assertIn("+faststart", command)
+ if failures:
+ self.assertNotIn("-hwaccel", captured[1][1])
+ self.assertIn("format=nv12,hwupload", captured[1][1])
+
+ def test_video_copy_does_not_probe_hardware(self):
+ service = TranscodeService(self.resolver, self.root / "cache")
+ commands = service._attempts(Path("ffmpeg"), self.source, self.root / "out.mp4",
+ _MediaProfile("h264", "yuv420p", "aac"))
+ with patch.object(service.hardware, "encoders") as encoders:
+ self.assertEqual(next(commands).name, "video-copy")
+ encoders.assert_not_called()
+
+ def test_hls_vaapi_failures_preserve_seek_timestamps_and_audio(self):
+ async def drive(failures):
+ service = HlsSegmentService(self.resolver, self.root / f"hls{failures}",
+ hardware=HardwareTranscoder())
+ captured = []
+
+ async def run(command, session, registry):
+ captured.append(command)
+ if len(captured) <= failures:
+ return 1, b"hardware failed"
+ Path(command[-1]).write_bytes(b"ts")
+ return 0, b""
+
+ with patch.object(service, "_run", side_effect=run), \
+ patch.object(service, "video_codec", return_value="hevc"):
+ target = await service.generate(self.source, 12, 6, asset_id=95, index=2,
+ session="test", registry=StreamSessionRegistry(), transcode=True)
+ self.assertEqual(target.read_bytes(), b"ts")
+ self.assertEqual(len(captured), failures + 1)
+ for command in captured:
+ self.assertEqual(command[command.index("-ss") + 1], "12.000")
+ self.assertEqual(command[command.index("-t") + 1], "6.000")
+ self.assertEqual(command[command.index("-output_ts_offset") + 1], "12.000")
+ self.assertEqual(command[command.index("-c:a") + 1], "aac")
+ self.assertEqual(command[command.index("-f") + 1], "mpegts")
+ self.assertIn("scale_vaapi=format=nv12", captured[0])
+ if failures:
+ self.assertIn("format=nv12,hwupload", captured[1])
+ if failures == 2:
+ self.assertIn("libx264", captured[2])
+
+ for failures in (0, 1, 2):
+ with self.subTest(failures=failures):
+ asyncio.run(drive(failures))
+
+ def test_hls_remux_does_not_probe_hardware(self):
+ service = HlsSegmentService(self.resolver, self.root / "hls", hardware=HardwareTranscoder())
+ with patch.object(service.hardware, "encoders") as encoders:
+ attempts = service._attempts(Path("ffmpeg"), self.source, 0, 6, False)
+ encoders.assert_not_called()
+ self.assertEqual([name for name, _ in attempts], ["copy"])
diff --git a/tests/test_segments.py b/tests/test_segments.py
index 6f1159481..0a7bc915e 100644
--- a/tests/test_segments.py
+++ b/tests/test_segments.py
@@ -8,6 +8,7 @@ from unittest import mock
from peach.mp4index import (
composition_offsets_present, keyframe_seconds, movie_seconds, segment_plan,
)
+from peach.hardware_transcode import HardwareEncoder
from peach.segments import HlsSegmentService, StreamSessionRegistry, build_hls_playlist
from support.mp4 import minimal_mp4
@@ -312,6 +313,9 @@ class SegmentCommandTests(unittest.TestCase):
work_root=root / "cache", prefer_hardware=True,
)
with mock.patch("asyncio.create_subprocess_exec", fake_exec), \
+ mock.patch("peach.hardware_transcode.HardwareTranscoder._candidates",
+ return_value=(HardwareEncoder("nvenc"),)), \
+ mock.patch("peach.hardware_transcode.HardwareTranscoder._probe", return_value=True), \
mock.patch("peach.segments._probe_video_codec", return_value=codec):
target = await service.generate(
source, 12.0, 6.0, asset_id=6562, index=2, session="s",
diff --git a/tests/test_transcodes.py b/tests/test_transcodes.py
index 55b760bf6..ad0084a3d 100644
--- a/tests/test_transcodes.py
+++ b/tests/test_transcodes.py
@@ -7,6 +7,7 @@ from pathlib import Path
from unittest.mock import patch
from peach.ffmpeg import BinaryChoice
+from peach.hardware_transcode import HardwareEncoder
from peach.transcodes import TranscodeCancelled, TranscodeService, TranscodeUnavailable
from support.mp4 import minimal_mp4
@@ -59,6 +60,15 @@ def _media_process(commands, profile, fail=None, duration=None):
class TranscodeServiceTests(unittest.TestCase):
+ def setUp(self):
+ candidates = patch("peach.hardware_transcode.HardwareTranscoder._candidates",
+ return_value=(HardwareEncoder("nvenc"),))
+ probe = patch("peach.hardware_transcode.HardwareTranscoder._probe", return_value=True)
+ candidates.start()
+ probe.start()
+ self.addCleanup(candidates.stop)
+ self.addCleanup(probe.stop)
+
def test_native_containers_are_checked_against_their_streams(self):
cases = (
(".mp4", "mpeg4", "yuv420p", "aac", True),