//! # vaapi_import_bench — VAAPI DMA-BUF 导入性能基准
//!
//! 本文件是 wl-webrtc 项目下的**独立可执行二进制**（位于 `src/bin/`），用于离线
//! 测量 "Portal 屏幕捕获 → DMA-BUF 导入到 VAAPI 硬件帧 → GPU 下采样 → 编码" 这条
//! 关键流水线的端到端耗时，并与 "CPU 软编" 路径作对比，输出每阶段平均毫秒数与 FPS。
//!
//! ## 流水线
//!
//! - **CPU 路径**：PipeWire BGRA 帧 → `sws_scale` 缩放 → libx264/libopenh264 软编
//! - **GPU 路径**：PipeWire DMA-BUF → `av_hwframe_map` → `scale_vaapi` 滤镜 → VAAPI H.264
//!
//! ## 与 Go benchmark 的类比
//!
//! 类似 Go 的 `testing.B`：先跑预热帧，再用 `Instant::now()` / `Duration::as_micros()`
//! 采集每个阶段的耗时（导入、缩放、传输、编码），最后输出 `FrameStats` 平均值。
//!
//! ## 用法
//!
//! ```bash
//! cargo run --bin vaapi_import_bench -- --output /tmp/vaapi_bench.mp4
//! cargo run --bin vaapi_import_bench -- --output /dev/null --mode gpu
//! cargo run --bin vaapi_import_bench -- --output /tmp/cpu.mp4 --mode cpu --frames 120
//! ```
//!
//! 详见 `AGENTS.md` 的 "Useful manual commands" 章节。

// vaapi_import_bench.rs — VAAPI DMA-BUF import + GPU-side downscale benchmark
//
// Tests: Portal capture -> av_hwframe_map (ARGB sw_format) -> transfer -> sw encode
//
// Usage: cargo run --bin vaapi_import_bench -- --output /tmp/vaapi_bench.mp4

// ===== 标准库导入 =====
// CString：FFI 传递给 C 函数的 NUL 结尾字符串；类比 Go 中显式末尾 0 的 []byte
// AsRawFd trait：把 Rust 的 OwnedFd 暴露为原始 int fd（用于 DMA-BUF 导入）
// Path：跨平台路径类型；类比 Go filepath
// ptr：FFI 裸指针工具（ptr::null_mut()、ptr::null()），类比 Go unsafe.Pointer(nil)
// Instant：高精度单调时钟；类比 Go time.Now()，用 elapsed() 取差值
use std::ffi::CString;
use std::os::fd::AsRawFd;
use std::path::Path;
use std::ptr;
use std::time::Instant;

// ===== 第三方 crate =====
// anyhow：Result<T> = Result<T, anyhow::Error>；bail! 宏提前返回 Err；类比 Go (T, error)
// clap：CLI 参数解析（Derive 宏）；本文件 BenchArgs 与 args.rs Args 都用此模式
use anyhow::{bail, Result};
use clap::{Parser, ValueEnum};

// ffmpeg_next：FFmpeg 绑定。ffi 子模块是 raw C FFI（含 unsafe），其余为高层封装
// packet::Mut trait：提供 as_mut_ptr()，用于拿到 AVPacket* 喂给 C API
use ffmpeg_next as ff;
use ffmpeg_next::ffi;
use ffmpeg_next::packet::Mut;

// 从本 crate (wl-webrtc) 复用：CLI Args、VAAPI 上下文、Portal 捕获
use wl_webrtc::args::Args;
use wl_webrtc::avhw::{import_dma_buf_to_vaapi, AvHwDevCtx, AvHwFrameCtx};
use wl_webrtc::cap_portal::{CapPortal, PwCtrlEvent};

/// 基准测试的 CLI 参数。Derive `Parser` 后 `BenchArgs::parse()` 即可从 argv 解析；
/// 类比 Go 中 `flag.StringVar` + `flag.Parse()`，但 Rust 用编译期宏生成代码。
///
/// 注意：与生产二进制 `wl-webrtc` 的 `Args`（见 `src/args.rs`）不同——这里是基准专用
/// 参数集（更细粒度的 enc_width/enc_height/mode），不复用 `Args`。
#[derive(Parser, Debug)]
#[command(name = "vaapi_import_bench", about = "VAAPI DMA-BUF import benchmark")]
struct BenchArgs {
    // 输出文件路径。如果包含 "null" 子串则使用 FFmpeg 的 null muxer（不写盘，只测编码耗时）
    #[arg(short, long)]
    output: String,

    // 总编码帧数；类比 Go benchmark 的 b.N，但这里是固定值（默认 60 帧）
    #[arg(long, default_value_t = 60)]
    frames: u32,

    // 编码器输出宽（GPU 路径会下采样到该尺寸）
    #[arg(long, default_value_t = 2560)]
    enc_width: u32,

    // 编码器输出高
    #[arg(long, default_value_t = 1440)]
    enc_height: u32,

    // DRM 渲染节点路径；VAAPI 上下文绑定到此设备（Intel iGPU 通常是 renderD128）
    #[arg(long, default_value = "/dev/dri/renderD128")]
    drm_device: String,

    // 流水线模式：cpu 只跑软编；gpu 只跑 VAAPI；both 两条路径都跑并对比
    #[arg(long, value_enum, default_value_t = PipelineMode::Both)]
    mode: PipelineMode,
}

/// 流水线模式选择。Derive `ValueEnum` 后 clap 自动把 "cpu"/"gpu"/"both" 字符串
/// 映射到枚举值；Derive `Copy` 让它在 match 时按值复制（无需 & 引用）。
#[derive(Copy, Clone, Debug, Eq, PartialEq, ValueEnum)]
enum PipelineMode {
    Cpu,
    Gpu,
    Both,
}

/// 单条流水线（CPU 或 GPU）运行结束后的统计聚合。每个 `Vec<u64>` 保存每帧的耗时（微秒）。
///
/// 类比 Go 的 `BenchmarkResult`：把 N 帧的逐次耗时收集起来，最后统一计算均值。
/// 用 `Vec<u64>` 而非流式累积是为了支持后续可能的中位数/分位数扩展。
#[derive(Default)]
struct FrameStats {
    // DMA-BUF 导入耗时（仅 GPU 路径有，CPU 路径为空）
    import_us: Vec<u64>,
    // GPU 滤镜图耗时（仅 GPU 路径有）
    filter_us: Vec<u64>,
    // CPU 路径的 sws_scale 耗时
    transfer_us: Vec<u64>,
    // 预留：缩放耗时单独拆分（当前与 filter_us/transfer_us 重叠）
    scale_us: Vec<u64>,
    // 像素格式转换耗时（BGRA → YUV420P）
    format_us: Vec<u64>,
    // 编码器 send_frame + drain_packet 总耗时
    encode_us: Vec<u64>,
    // 单帧总耗时（capture_start → encode_done），用于理论 FPS
    total_us: Vec<u64>,
    // 导入失败的次数（DMA-BUF fd 失效等）
    import_failures: u32,
    // 实际成功编码的帧数
    frames_encoded: u32,
    // 端到端墙钟耗时（从首帧到末帧），用于实测 FPS
    elapsed_secs: f64,
    // 编码器名称（libx264 / libopenh264 / h264_vaapi）
    codec_name: String,
    // 输出路径（区分 cpu / gpu 文件名）
    output_path: String,
}

impl FrameStats {
    // 计算每帧耗时的均值（微秒 → 毫秒）；空 Vec 返回 0.0 避免除零
    fn avg_ms(data: &[u64]) -> f64 {
        if data.is_empty() {
            return 0.0;
        }
        // sum::<u64>() 显式指定求和类型，避免类型推导失败；类比 Go 的 for-range 累加
        data.iter().sum::<u64>() as f64 / data.len() as f64 / 1000.0
    }

    // 单帧总耗时的均值（毫秒），用于报告 "平均每帧 X ms"
    fn avg_total_ms(&self) -> f64 {
        Self::avg_ms(&self.total_us)
    }

    // 实测 FPS = 成功编码帧数 / 墙钟耗时；避免零除返回 0.0
    fn achieved_fps(&self) -> f64 {
        if self.frames_encoded > 0 && self.elapsed_secs > 0.0 {
            self.frames_encoded as f64 / self.elapsed_secs
        } else {
            0.0
        }
    }

    // 理论 FPS = 1000 / 平均单帧总耗时（仅编码侧上限，不含 PipeWire 等待）
    fn theoretical_fps(&self) -> f64 {
        let avg = self.avg_total_ms();
        if avg > 0.0 {
            1000.0 / avg
        } else {
            0.0
        }
    }
}

/// CPU 软编路径的状态聚合体：编码器、输出容器、可复用的 YUV 帧。
///
/// 字段 `yuv_frame` 是裸指针 `*mut ffi::AVFrame`——因为 FFmpeg C API 要求长生命周期
/// 的可变指针，且需要 Drop 时显式释放。裸指针 `*mut T` 默认非 Send/Sync，但本结构体
/// 只在主线程使用，无需跨线程传递，因此无需手动 impl Send。
struct SoftwareEncoder {
    enc_video: ff::codec::encoder::video::Video,
    octx: ff::format::context::Output,
    yuv_frame: *mut ffi::AVFrame,
    codec_name: String,
}

// Drop trait 类比 Go 的 `defer cleanup()`：结构体析构时由 Rust 自动调用，
// 避免裸指针 yuv_frame 泄漏。注意 Drop 内不能再使用 self.yuv_frame，只能释放
impl Drop for SoftwareEncoder {
    fn drop(&mut self) {
        // Drop trait 类比 Go 的 `defer cleanup()`：结构体析构时自动调用
        // SAFETY: yuv_frame is allocated by av_frame_alloc in create_software_encoder and
        // owned exclusively by this SoftwareEncoder.
        unsafe {
            ffi::av_frame_free(&mut self.yuv_frame);
        }
    }
}

/// FFmpeg `sws_scale` 上下文的拥有型包装。Newtype 模式（tuple struct 单字段）让
/// Rust 类型系统追踪 C 资源的所有权，并通过 Drop 自动释放；类比 Go 中
/// `type SwsContext struct{ p *C.SwsContext }` + `func (s *SwsContext) Close()`。
struct SwsContext(*mut ffi::SwsContext);

impl Drop for SwsContext {
    fn drop(&mut self) {
        // sws_freeContext 接受 NULL 是安全的（C 规范），无需额外判空
        // SAFETY: Context is either null or returned by sws_getContext and owned here.
        unsafe {
            ffi::sws_freeContext(self.0);
        }
    }
}

/// 把 FFmpeg 错误码（负数）翻译成人类可读字符串。FFmpeg 的错误码没有官方码表，
/// 必须通过 `av_strerror` 拿到文本；类比 Go 中 `errno.String()` 或 `os.PathError.Err`。
fn av_err_to_string(ret: i32) -> String {
    // 准备 128 字节缓冲区（FFmpeg 习惯用 128），由 av_strerror 写入 NUL 结尾的 C 字符串
    let mut buf = vec![0u8; 128];
    // SAFETY: av_strerror 最多写 128 字节并以 NUL 结尾；buf 是独占的可变 Vec<u8>，
    // as_mut_ptr 把缓冲区首字节暴露给 C，借用仅在这次调用期间有效。
    unsafe {
        ffi::av_strerror(ret, buf.as_mut_ptr() as *mut i8, buf.len());
    }
    // 找到首个 NUL 字节作为字符串末尾，再 from_utf8_lossy 容错转 String
    let end = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
    String::from_utf8_lossy(&buf[..end]).to_string()
}

/// 阻塞等待第一帧 PipeWire DMA-BUF 到达；类比 Go 的 `chan.Recv()` 配 `select`。
///
/// 同时监听控制通道（StreamEnded / FormatChanged / Error），任何错误都立即 `bail!`。
/// 超时 10 秒防止 GPU/驱动卡死导致基准测试无限挂起。
fn receive_first_frame(cap: &CapPortal) -> Result<wl_webrtc::cap_portal::PwDmaBufFrame> {
    loop {
        // 控制通道：非阻塞 try_recv（类比 Go `select { case e := <-ctrl: ... default: }`）
        if let Ok(ctrl) = cap.event_receiver().try_recv() {
            match ctrl {
                PwCtrlEvent::StreamEnded => bail!("PipeWire stream ended before first frame"),
                PwCtrlEvent::FormatChanged { .. } => {}
                PwCtrlEvent::Error(e) => bail!("PipeWire error: {e}"),
            }
        }
        // 帧通道：阻塞等待最多 10 秒
        // 类比 Go `select { case f := <-frame: ... case <-time.After(10*time.Second): bail! }`
        match cap
            .frame_receiver()
            .recv_timeout(std::time::Duration::from_secs(10))
        {
            Ok(frame) => return Ok(frame),
            Err(crossbeam_channel::RecvTimeoutError::Timeout) => {
                bail!("Timeout waiting for first frame (10s)");
            }
            Err(crossbeam_channel::RecvTimeoutError::Disconnected) => {
                bail!("PipeWire frame channel disconnected");
            }
        }
    }
}

/// 从编码器循环拉取已编码的 packet 并写入输出容器，直到编码器返回 EAGAIN/EOF。
///
/// "Drain" 模式：调用 `avcodec_send_frame` 后必须连续 `avcodec_receive_packet` 直到
/// EAGAIN，否则编码器内部缓冲区会堵塞，下一帧 send_frame 会失败。
fn drain_encoder(
    enc_video: &mut ff::codec::encoder::video::Video,
    octx: &mut ff::format::context::Output,
) -> Result<()> {
    loop {
        let mut pkt = ff::Packet::empty();
        // SAFETY: enc_video.as_mut_ptr() 指向已打开的编码器上下文；pkt.as_mut_ptr()
        // 指向空 packet，FFmpeg 会在此调用中分配 packet 数据。
        let ret = unsafe { ffi::avcodec_receive_packet(enc_video.as_mut_ptr(), pkt.as_mut_ptr()) };
        if ret < 0 {
            // EAGAIN = 编码器还需要更多输入帧；EOF = 已 flush；两者都是正常终止
            if ret == ffi::AVERROR(ffi::EAGAIN) || ret == ffi::AVERROR_EOF {
                break;
            }
            eprintln!("avcodec_receive_packet failed: {ret}");
            break;
        }
        // 把 PTS 从编码器时间基重缩放为输出流的时间基（视频流可有不同 time_base）
        let enc_tb = enc_video.time_base();
        // SAFETY: octx.as_ptr() 指向有效的 AVFormatContext；streams 数组至少有一个流
        // （在 create_software_encoder 中由 avformat_new_stream 创建）。
        let stream_tb = unsafe {
            let streams = (*octx.as_ptr()).streams;
            let st = *streams.add(0);
            ff::Rational::from((*st).time_base)
        };
        pkt.rescale_ts(enc_tb, stream_tb);
        pkt.set_stream(0);
        // write_interleaved 让 FFmpeg 自动按 DTS 排序，避免手动管理 PTS/DTS
        pkt.write_interleaved(octx)
            .map_err(|e| anyhow::anyhow!("write packet failed: {e}"))?;
    }
    Ok(())
}

/// 初始化 libx264/libopenh264 软编码器 + 输出容器（MP4/null muxer）+ 可复用 YUV420P 帧。
///
/// 这是基准 CPU 路径的核心装配函数，步骤依次为：
/// 1. 寻找 codec（libx264 优先，libopenh264 回退）
/// 2. 创建 encoder context（builder 模式）
/// 3. 设置 width/height/fps/time_base/GOP
/// 4. （libx264 专属）设置 preset/tune
/// 5. 打开编码器
/// 6. 分配 AVFormatContext + 创建流 + 复制 codec parameters
/// 7. 打开输出文件（除非 null muxer）+ 写文件头
/// 8. 分配可复用的 YUV420P 帧（在每帧 encode 时复用）
fn create_software_encoder(output_path: &Path, width: u32, height: u32) -> Result<SoftwareEncoder> {
    // CString 必须在 unsafe 块外构造，确保 NUL 结尾的字符串生命周期覆盖下面的 FFI 调用
    let output_cstr = CString::new(output_path.to_str().unwrap())?;
    // 优先 libx264（性能最好，GPL 协议），其次 libopenh264（BSD，回退方案）
    let codec = ff::encoder::find_by_name("libx264")
        .or_else(|| ff::encoder::find_by_name("libopenh264"))
        .ok_or_else(|| {
            anyhow::anyhow!("No H.264 software encoder found (tried libx264, libopenh264)")
        })?;

    let codec_name = codec.name().to_string();
    // 两阶段构造：先 Context::new_with_codec 拿到 builder，再 .encoder().video()? 切到视频编码视图
    let mut enc = {
        let ctx = ff::codec::Context::new_with_codec(codec);
        ctx.encoder().video()?
    };

    // 编码器参数：分辨率、像素格式、时基、GOP 结构
    enc.set_width(width);
    enc.set_height(height);
    enc.set_format(ff::format::Pixel::YUV420P);
    // time_base = 1/60，与基准测试默认 60 FPS 对齐；生产代码里通常从源流继承
    enc.set_time_base(ff::Rational::new(1, 60));
    // 关闭 B 帧以降低延迟（基准不追求压缩率）
    enc.set_max_b_frames(0);
    // GOP = 60：每 60 帧一个 I 帧（与 60 FPS 对齐 = 每秒一个 IDR 帧）
    enc.set_gop(60);

    // libx264 的私有参数 preset/tune 必须在 encoder 打开前通过 av_opt_set 设置到 priv_data
    if codec_name == "libx264" {
        // SAFETY: priv_data belongs to the not-yet-opened encoder context. Option strings are
        // valid NUL-terminated C strings for the duration of each av_opt_set call.
        unsafe {
            let key = CString::new("preset").unwrap();
            let val = CString::new("veryfast").unwrap();
            ffi::av_opt_set((*enc.as_mut_ptr()).priv_data, key.as_ptr(), val.as_ptr(), 0);
            let key = CString::new("tune").unwrap();
            let val = CString::new("zerolatency").unwrap();
            ffi::av_opt_set((*enc.as_mut_ptr()).priv_data, key.as_ptr(), val.as_ptr(), 0);
        }
    }

    // 真正打开编码器（前面只是 builder 状态），此后 enc_video 进入 ready 状态
    let opened = enc.open()?;
    let enc_video = opened.0;

    // 输出文件名含 "null" → 用 FFmpeg 内置 null muxer（不写盘），适合纯 CPU 基准
    let use_null_muxer = output_path
        .to_str()
        .map(|s| s.contains("null"))
        .unwrap_or(false);
    let fmt_name = if use_null_muxer {
        CString::new("null").unwrap()
    } else {
        CString::new("").unwrap()
    };
    let fmt_name_ptr = if use_null_muxer {
        fmt_name.as_ptr()
    } else {
        ptr::null()
    };

    let mut fmt_ctx_ptr: *mut ffi::AVFormatContext = ptr::null_mut();
    // SAFETY: fmt_ctx_ptr is an out pointer initialized by FFmpeg; output_cstr and fmt_name live
    // across the call.
    let ret = unsafe {
        ffi::avformat_alloc_output_context2(
            &mut fmt_ctx_ptr,
            ptr::null_mut(),
            fmt_name_ptr,
            output_cstr.as_ptr(),
        )
    };
    if ret < 0 || fmt_ctx_ptr.is_null() {
        bail!("Failed to allocate output format context: error {ret}");
    }

    // SAFETY: fmt_ctx_ptr is a valid output context allocated above.
    let stream_ptr = unsafe { ffi::avformat_new_stream(fmt_ctx_ptr, ptr::null()) };
    if stream_ptr.is_null() {
        bail!("Failed to create output stream");
    }

    // SAFETY: stream and codec context pointers are valid; parameters are copied into stream.
    let ret =
        unsafe { ffi::avcodec_parameters_from_context((*stream_ptr).codecpar, enc_video.as_ptr()) };
    if ret < 0 {
        bail!("Failed to copy codec parameters: error {ret}");
    }

    // SAFETY: fmt_ctx_ptr is valid; pb is initialized for non-NOFILE muxers.
    // AVFMT_NOFILE 表示该 muxer 不需要物理文件（如 null muxer），跳过 avio_open
    unsafe {
        if (*(*fmt_ctx_ptr).oformat).flags & ffi::AVFMT_NOFILE == 0 {
            let ret = ffi::avio_open(
                &mut (*fmt_ctx_ptr).pb,
                output_cstr.as_ptr(),
                ffi::AVIO_FLAG_WRITE,
            );
            if ret < 0 {
                bail!("Failed to open output file: error {ret}");
            }
        }
    }

    // SAFETY: fmt_ctx_ptr is a fully configured output context.
    let ret = unsafe { ffi::avformat_write_header(fmt_ctx_ptr, ptr::null_mut()) };
    if ret < 0 {
        bail!("Failed to write header: error {ret}");
    }

    // SAFETY: ownership of fmt_ctx_ptr transfers into ffmpeg-next Output wrapper.
    // 此后 octx 拥有 fmt_ctx_ptr，会在 Drop 时调用 avformat_free_context
    let octx = unsafe { ff::format::context::Output::wrap(fmt_ctx_ptr) };

    // SAFETY: Allocate and configure an owned writable YUV420P frame for encoder input.
    // 这个 yuv_frame 在每次 encode_yuv_frame 中复用（不重新分配），由 SoftwareEncoder::drop 释放
    let yuv_frame = unsafe {
        let mut f = ffi::av_frame_alloc();
        if f.is_null() {
            bail!("av_frame_alloc failed");
        }
        (*f).width = width as i32;
        (*f).height = height as i32;
        (*f).format = ffi::AVPixelFormat::AV_PIX_FMT_YUV420P as i32;
        let r = ffi::av_frame_get_buffer(f, 0);
        if r < 0 {
            ffi::av_frame_free(&mut f);
            bail!("av_frame_get_buffer failed: {r}");
        }
        f
    };

    Ok(SoftwareEncoder {
        enc_video,
        octx,
        yuv_frame,
        codec_name,
    })
}

/// 根据 `PipelineMode` 在文件名中插入 `cpu` 或 `gpu` 后缀，让 both 模式下两条路径不互相覆盖。
///
/// 例：`/tmp/out.mp4` + `PipelineMode::Cpu` → `/tmp/out.cpu.mp4`。
/// `split=false` 或文件名含 "null" 时直接返回原路径（null muxer 不需要分裂）。
fn output_for_mode(base: &str, mode: PipelineMode, split: bool) -> String {
    if !split || base.contains("null") {
        return base.to_string();
    }

    let path = Path::new(base);
    // match 在 Rust 中默认是穷尽的（编译器强制覆盖所有 enum 变体）；
    // 这里 Both 在调用前已被外层排除，用 unreachable!() 标记
    let suffix = match mode {
        PipelineMode::Cpu => "cpu",
        PipelineMode::Gpu => "gpu",
        PipelineMode::Both => unreachable!(),
    };
    // file_name 返回 Option<&OsStr>，and_then + to_str 链式处理 None 情况
    let file_name = path.file_name().and_then(|s| s.to_str()).unwrap_or(base);
    // rsplit_once 类比 Go 的 strings.Cut：从右侧切分一次扩展名（保留 "a.b.c" 中的 "a.b" 与 "c"）
    let split_name = if let Some((stem, ext)) = file_name.rsplit_once('.') {
        format!("{stem}.{suffix}.{ext}")
    } else {
        format!("{file_name}.{suffix}")
    };
    // with_file_name 保留父目录，只替换末尾文件名；to_string_lossy 容错 OsStr → &str
    path.with_file_name(split_name)
        .to_string_lossy()
        .into_owned()
}

/// 创建 BGRA→YUV420P 的 swscale 上下文。`SwsContext` 是 CPU 路径的颜色空间/尺寸转换核心。
///
/// 第 7 个参数 `2` = bicubic 算法；FFmpeg 还提供 fast_bilinear(1) / bilinear(2) /
/// lanczos(16) 等。基准选 bicubic 是平衡速度与质量。
fn create_sws_context(
    src_width: u32,
    src_height: u32,
    src_fmt: ffi::AVPixelFormat,
    dst_width: u32,
    dst_height: u32,
) -> Result<SwsContext> {
    // SAFETY: sws_getContext creates an owned scaler context for the provided dimensions/formats.
    // 返回的 *mut SwsContext 由 SwsContext 包装并在 Drop 中通过 sws_freeContext 释放。
    let ctx = unsafe {
        ffi::sws_getContext(
            src_width as i32,
            src_height as i32,
            src_fmt,
            dst_width as i32,
            dst_height as i32,
            ffi::AVPixelFormat::AV_PIX_FMT_YUV420P,
            2,
            ptr::null_mut(),
            ptr::null_mut(),
            ptr::null_mut(),
        )
    };
    if ctx.is_null() {
        bail!("Failed to create sws_scale context");
    }
    Ok(SwsContext(ctx))
}

/// 把已填好 YUV420P 数据的 `encoder.yuv_frame` 送入编码器，并 drain 已编码 packet。
/// 返回编码阶段的耗时（微秒），用于 `FrameStats::encode_us` 统计。
fn encode_yuv_frame(encoder: &mut SoftwareEncoder, pts: &mut i64) -> Result<u64> {
    // 类比 Go time.Now()；用 as_micros() as u64 转 u64（u128 截断不影响 60s 量级基准）
    let t_encode = Instant::now();
    // SAFETY: yuv_frame is allocated, writable, and formatted as the encoder's configured
    // YUV420P input frame. FFmpeg consumes but does not take ownership.
    unsafe {
        // 单调递增的 PTS；FFmpeg 要求 PTS 必须按 time_base 单位递增，否则丢帧
        (*encoder.yuv_frame).pts = *pts;
        *pts += 1;
        let r = ffi::avcodec_send_frame(encoder.enc_video.as_mut_ptr(), encoder.yuv_frame);
        if r < 0 {
            bail!("avcodec_send_frame failed: {r}");
        }
    }
    // drain 编码器缓冲区（必须，否则下一帧 send_frame 会 EAGAIN）
    drain_encoder(&mut encoder.enc_video, &mut encoder.octx)?;
    Ok(t_encode.elapsed().as_micros() as u64)
}

/// 编码结束：发送 NULL frame 触发编码器 flush，drain 残余 packet，写入文件尾（trailer）。
///
/// 类比 Go 中 `io.Closer`：必须按顺序 (flush → drain → trailer) 才能产出可播放的文件。
fn finish_encoder(mut encoder: SoftwareEncoder) -> Result<()> {
    // SAFETY: Sending a null frame flushes the encoder; context remains owned by encoder.
    unsafe {
        ffi::avcodec_send_frame(encoder.enc_video.as_mut_ptr(), ptr::null());
    }
    drain_encoder(&mut encoder.enc_video, &mut encoder.octx)?;
    encoder
        .octx
        .write_trailer()
        .map_err(|e| anyhow::anyhow!("Failed to write trailer: {e}"))?;
    Ok(())
}

/// 把 PipeWire 给的 DMA-BUF 帧导入 VAAPI 硬件帧上下文，返回 `ff::frame::Video`（GPU 帧）。
/// 这是 GPU 路径的入口；耗时由 `FrameStats::import_us` 统计。
fn import_frame(
    frames_ctx: &AvHwFrameCtx,
    frame: &wl_webrtc::cap_portal::PwDmaBufFrame,
) -> Result<ff::frame::Video> {
    // SAFETY: frames_ctx is a live VAAPI frames context configured for the capture format; frame
    // carries a valid DMA-BUF fd and metadata from PipeWire for the duration of the call.
    unsafe {
        import_dma_buf_to_vaapi(
            frames_ctx.as_ptr(),
            frame.fd.as_raw_fd(),
            frame.width,
            frame.height,
            frame.format,
            frame.modifier,
            frame.stride,
            frame.offset,
        )
    }
}

/// 构建 GPU 路径的 FFmpeg 滤镜图：`buffer`（CPU 入口）→ `scale_vaapi`（GPU 缩放+格式转换）→ `buffersink`。
///
/// 关键点：buffer 滤镜不能用 pix_fmt=VAAPI 直接初始化（FFmpeg 8+ 会拒绝），
/// 必须用 `av_buffersrc_parameters_set` 注入 hw_frames_ctx 才能让后续 VAAPI 滤镜识别。
fn build_gpu_filter_graph(
    hw_dev: &AvHwDevCtx,
    frames_rgb: &AvHwFrameCtx,
    width: u32,
    height: u32,
    enc_width: u32,
    enc_height: u32,
) -> Result<ff::filter::Graph> {
    let mut graph = ff::filter::Graph::new();
    // buffer = 滤镜图入口，从 AVFrame 注入数据
    let buffersrc =
        ff::filter::find("buffer").ok_or_else(|| anyhow::anyhow!("filter 'buffer' not found"))?;
    // buffersink = 滤镜图出口，取出处理后的 AVFrame
    let buffersink = ff::filter::find("buffersink")
        .ok_or_else(|| anyhow::anyhow!("filter 'buffersink' not found"))?;
    // scale_vaapi = VAAPI 硬件缩放 + 格式转换（BGRA→NV12）
    let scale_vaapi = ff::filter::find("scale_vaapi")
        .ok_or_else(|| anyhow::anyhow!("filter 'scale_vaapi' not found"))?;

    // pix_fmt must be set via av_buffersrc_parameters_set (below), not in args —
    // FFmpeg 8.0+ rejects HW pixel formats during init() if hw_frames_ctx is missing.
    // Use a placeholder SW format here; it gets overridden by parameters_set below.
    let args = format!(
        "video_size={}x{}:pix_fmt=bgra:time_base=1/60:pixel_aspect=1/1",
        width, height,
    );
    let mut src_ctx = graph.add(&buffersrc, "in", &args)?;

    // SAFETY: Allocate buffersrc parameters, attach a ref-counted hw_frames_ctx compatible with
    // imported VAAPI BGRA frames, apply it, then free only the parameter struct (not the ref).
    let par = unsafe { ffi::av_buffersrc_parameters_alloc() };
    if par.is_null() {
        bail!("av_buffersrc_parameters_alloc returned null");
    }
    // SAFETY: par and src_ctx are valid; frames_rgb.ref_clone returns an owned AVBufferRef.
    unsafe {
        (*par).format = Into::<ffi::AVPixelFormat>::into(ff::format::Pixel::VAAPI) as i32;
        (*par).width = width as i32;
        (*par).height = height as i32;
        (*par).time_base = ffi::AVRational { num: 1, den: 60 };
        // ref_clone 增加引用计数（AVBufferRef 共享底层 AVHWFramesContext），
        // FFmpeg 内部会持有这个引用直到 buffersrc 释放
        (*par).hw_frames_ctx = frames_rgb.ref_clone();
        let ret = ffi::av_buffersrc_parameters_set(src_ctx.as_mut_ptr(), par);
        // 只释放参数结构体本身；AVBufferRef 的引用由 buffersrc 持有，不能在这里 free
        ffi::av_free(par as *mut _);
        if ret < 0 {
            bail!("av_buffersrc_parameters_set failed: error {ret}");
        }
    }

    // scale_vaapi 滤镜参数：缩放到 enc_width×enc_height，输出 NV12（VAAPI H.264 要求的输入格式）
    let mut scale_ctx = graph.add(
        &scale_vaapi,
        "scale",
        &format!("{enc_width}:{enc_height}:format=nv12"),
    )?;
    // SAFETY: scale_vaapi uses this ref-counted VAAPI device context while graph is alive.
    unsafe {
        (*scale_ctx.as_mut_ptr()).hw_device_ctx = hw_dev.ref_clone();
    }

    let mut sink_ctx = graph.add(&buffersink, "out", "")?;
    // 链接：in[0] → scale[0] → out[0]，pad index 0 是默认输入/输出口
    src_ctx.link(0, &mut scale_ctx, 0);
    scale_ctx.link(0, &mut sink_ctx, 0);
    graph
        .validate()
        .map_err(|e| anyhow::anyhow!("GPU filter graph validation failed: {e}"))?;

    Ok(graph)
}

#[allow(clippy::too_many_arguments)]
fn run_cpu_pipeline(
    cap: &CapPortal,
    frames_ctx: &AvHwFrameCtx,
    output: &str,
    frames: u32,
    src_width: u32,
    src_height: u32,
    enc_width: u32,
    enc_height: u32,
) -> Result<FrameStats> {
    let mut encoder = create_software_encoder(Path::new(output), enc_width, enc_height)?;
    let sws_ctx = create_sws_context(
        src_width,
        src_height,
        ffi::AVPixelFormat::AV_PIX_FMT_BGRA,
        enc_width,
        enc_height,
    )?;

    println!(
        "       Encoder: {}, {}x{} YUV420P",
        encoder.codec_name, enc_width, enc_height
    );
    println!("       Output: {output}");
    println!("       CPU Pipeline: DMA-BUF 4K BGRA -> av_hwframe_map -> av_hwframe_transfer_data -> sws_scale -> YUV420P 2K -> encode\n");

    let mut stats = FrameStats {
        codec_name: encoder.codec_name.clone(),
        output_path: output.to_string(),
        ..FrameStats::default()
    };
    let total_start = Instant::now();
    let mut pts: i64 = 0;

    while stats.frames_encoded < frames {
        if let Ok(ctrl) = cap.event_receiver().try_recv() {
            match ctrl {
                PwCtrlEvent::StreamEnded => break,
                PwCtrlEvent::Error(e) => bail!(
                    "PipeWire error after {} CPU frames: {e}",
                    stats.frames_encoded
                ),
                PwCtrlEvent::FormatChanged { .. } => {}
            }
        }

        let frame = match cap
            .frame_receiver()
            .recv_timeout(std::time::Duration::from_secs(5))
        {
            Ok(f) => f,
            Err(_) => break,
        };

        let frame_start = Instant::now();
        let t_import = Instant::now();
        let vaapi_frame = match import_frame(frames_ctx, &frame) {
            Ok(f) => f,
            Err(e) => {
                stats.import_failures += 1;
                if stats.import_failures <= 3 {
                    eprintln!("CPU frame {}: import failed: {e}", stats.frames_encoded);
                }
                continue;
            }
        };
        let import_us = t_import.elapsed().as_micros() as u64;

        let t_transfer = Instant::now();
        // SAFETY: sw_frame is allocated by FFmpeg and freed on all paths below.
        let mut sw_frame = unsafe { ffi::av_frame_alloc() };
        if sw_frame.is_null() {
            bail!("CPU frame {}: av_frame_alloc failed", stats.frames_encoded);
        }
        // SAFETY: sw_frame is an allocated destination; vaapi_frame is a valid VAAPI source frame.
        let transfer_ret =
            unsafe { ffi::av_hwframe_transfer_data(sw_frame, vaapi_frame.as_ptr(), 0) };
        if transfer_ret < 0 {
            // SAFETY: sw_frame was allocated above and has not been freed yet.
            unsafe { ffi::av_frame_free(&mut sw_frame) };
            bail!(
                "CPU frame {}: av_hwframe_transfer_data failed: {} ({})",
                stats.frames_encoded,
                transfer_ret,
                av_err_to_string(transfer_ret)
            );
        }
        let transfer_us = t_transfer.elapsed().as_micros() as u64;

        let t_scale = Instant::now();
        // SAFETY: sw_frame contains transferred BGRA data; encoder.yuv_frame is writable YUV420P
        // at the configured output dimensions; sws_ctx converts and downscales between them.
        unsafe {
            ffi::av_frame_make_writable(encoder.yuv_frame);
            ffi::sws_scale(
                sws_ctx.0,
                (*sw_frame).data.as_ptr() as *const *const u8,
                (*sw_frame).linesize.as_ptr() as *const i32,
                0,
                (*sw_frame).height,
                (*encoder.yuv_frame).data.as_ptr() as *mut *mut u8,
                (*encoder.yuv_frame).linesize.as_ptr() as *const i32,
            );
        }
        let scale_us = t_scale.elapsed().as_micros() as u64;
        // SAFETY: sw_frame was allocated above and is no longer needed after scaling.
        unsafe { ffi::av_frame_free(&mut sw_frame) };

        let encode_us = encode_yuv_frame(&mut encoder, &mut pts)?;
        let total_us = frame_start.elapsed().as_micros() as u64;

        stats.import_us.push(import_us);
        stats.transfer_us.push(transfer_us);
        stats.scale_us.push(scale_us);
        stats.encode_us.push(encode_us);
        stats.total_us.push(total_us);
        stats.frames_encoded += 1;

        if stats.frames_encoded <= 3 || stats.frames_encoded % 30 == 0 {
            println!(
                "       CPU frame {:>4}/{frames}: import={:.2}ms transfer={:.2}ms scale={:.2}ms encode={:.2}ms total={:.2}ms",
                stats.frames_encoded,
                import_us as f64 / 1000.0,
                transfer_us as f64 / 1000.0,
                scale_us as f64 / 1000.0,
                encode_us as f64 / 1000.0,
                total_us as f64 / 1000.0,
            );
        }
    }

    finish_encoder(encoder)?;
    stats.elapsed_secs = total_start.elapsed().as_secs_f64();
    Ok(stats)
}

#[allow(clippy::too_many_arguments)]
fn run_gpu_pipeline(
    cap: &CapPortal,
    hw_dev: &AvHwDevCtx,
    frames_ctx: &AvHwFrameCtx,
    output: &str,
    frames: u32,
    src_width: u32,
    src_height: u32,
    enc_width: u32,
    enc_height: u32,
) -> Result<FrameStats> {
    let mut encoder = create_software_encoder(Path::new(output), enc_width, enc_height)?;
    let format_ctx = create_sws_context(
        enc_width,
        enc_height,
        ffi::AVPixelFormat::AV_PIX_FMT_NV12,
        enc_width,
        enc_height,
    )?;
    let mut graph = build_gpu_filter_graph(
        hw_dev, frames_ctx, src_width, src_height, enc_width, enc_height,
    )?;

    println!(
        "       Encoder: {}, {}x{} YUV420P",
        encoder.codec_name, enc_width, enc_height
    );
    println!("       Output: {output}");
    println!("       GPU Pipeline: DMA-BUF 4K BGRA -> av_hwframe_map -> scale_vaapi 2K NV12 -> transfer small NV12 -> sws_scale format-only -> encode\n");

    let mut stats = FrameStats {
        codec_name: encoder.codec_name.clone(),
        output_path: output.to_string(),
        ..FrameStats::default()
    };
    let total_start = Instant::now();
    let mut pts: i64 = 0;

    while stats.frames_encoded < frames {
        if let Ok(ctrl) = cap.event_receiver().try_recv() {
            match ctrl {
                PwCtrlEvent::StreamEnded => break,
                PwCtrlEvent::Error(e) => bail!(
                    "PipeWire error after {} GPU frames: {e}",
                    stats.frames_encoded
                ),
                PwCtrlEvent::FormatChanged { .. } => {}
            }
        }

        let frame = match cap
            .frame_receiver()
            .recv_timeout(std::time::Duration::from_secs(5))
        {
            Ok(f) => f,
            Err(_) => break,
        };

        let frame_start = Instant::now();
        let t_import = Instant::now();
        let vaapi_frame = match import_frame(frames_ctx, &frame) {
            Ok(f) => f,
            Err(e) => {
                stats.import_failures += 1;
                if stats.import_failures <= 3 {
                    eprintln!("GPU frame {}: import failed: {e}", stats.frames_encoded);
                }
                continue;
            }
        };
        let import_us = t_import.elapsed().as_micros() as u64;

        let t_filter = Instant::now();
        let mut filter_src_ctx = graph.get("in").unwrap();
        let mut filter_src = filter_src_ctx.source();
        let mut filter_sink_ctx = graph.get("out").unwrap();
        let mut filter_sink = filter_sink_ctx.sink();
        filter_src
            .add(&vaapi_frame)
            .map_err(|e| anyhow::anyhow!("GPU filter source add failed: {e}"))?;

        let mut filtered = ff::frame::Video::empty();
        match filter_sink.frame(&mut filtered) {
            Ok(()) => {}
            Err(ff::Error::Other { errno }) if errno == ffi::EAGAIN => continue,
            Err(e) => bail!("GPU filter sink get frame failed: {e}"),
        }
        let filter_us = t_filter.elapsed().as_micros() as u64;

        let t_transfer = Instant::now();
        // SAFETY: sw_nv12 is allocated by FFmpeg and freed after format conversion.
        let mut sw_nv12 = unsafe { ffi::av_frame_alloc() };
        if sw_nv12.is_null() {
            bail!("GPU frame {}: av_frame_alloc failed", stats.frames_encoded);
        }
        // SAFETY: sw_nv12 is an allocated destination; filtered is a valid 2K NV12 VAAPI frame.
        let transfer_ret = unsafe { ffi::av_hwframe_transfer_data(sw_nv12, filtered.as_ptr(), 0) };
        if transfer_ret < 0 {
            // SAFETY: sw_nv12 was allocated above and has not been freed yet.
            unsafe { ffi::av_frame_free(&mut sw_nv12) };
            bail!(
                "GPU frame {}: av_hwframe_transfer_data failed: {} ({})",
                stats.frames_encoded,
                transfer_ret,
                av_err_to_string(transfer_ret)
            );
        }
        let transfer_us = t_transfer.elapsed().as_micros() as u64;

        let t_format = Instant::now();
        // SAFETY: sw_nv12 contains CPU-side NV12 at enc dimensions; encoder.yuv_frame is writable
        // YUV420P at the same dimensions, so sws_scale performs only chroma deinterleave/format conversion.
        unsafe {
            ffi::av_frame_make_writable(encoder.yuv_frame);
            ffi::sws_scale(
                format_ctx.0,
                (*sw_nv12).data.as_ptr() as *const *const u8,
                (*sw_nv12).linesize.as_ptr() as *const i32,
                0,
                (*sw_nv12).height,
                (*encoder.yuv_frame).data.as_ptr() as *mut *mut u8,
                (*encoder.yuv_frame).linesize.as_ptr() as *const i32,
            );
        }
        let format_us = t_format.elapsed().as_micros() as u64;
        // SAFETY: sw_nv12 was allocated above and is no longer needed.
        unsafe { ffi::av_frame_free(&mut sw_nv12) };

        let encode_us = encode_yuv_frame(&mut encoder, &mut pts)?;
        let total_us = frame_start.elapsed().as_micros() as u64;

        stats.import_us.push(import_us);
        stats.filter_us.push(filter_us);
        stats.transfer_us.push(transfer_us);
        stats.format_us.push(format_us);
        stats.encode_us.push(encode_us);
        stats.total_us.push(total_us);
        stats.frames_encoded += 1;

        if stats.frames_encoded <= 3 || stats.frames_encoded % 30 == 0 {
            println!(
                "       GPU frame {:>4}/{frames}: import={:.2}ms filter={:.2}ms transfer={:.2}ms format={:.2}ms encode={:.2}ms total={:.2}ms",
                stats.frames_encoded,
                import_us as f64 / 1000.0,
                filter_us as f64 / 1000.0,
                transfer_us as f64 / 1000.0,
                format_us as f64 / 1000.0,
                encode_us as f64 / 1000.0,
                total_us as f64 / 1000.0,
            );
        }
    }

    finish_encoder(encoder)?;
    stats.elapsed_secs = total_start.elapsed().as_secs_f64();
    Ok(stats)
}

fn print_detailed_results(
    label: &str,
    stats: &FrameStats,
    src_width: u32,
    src_height: u32,
    enc_width: u32,
    enc_height: u32,
) {
    println!();
    println!("=== {label} Pipeline Results ===");
    println!("Capture resolution: {}x{}", src_width, src_height);
    println!("Encode resolution:  {}x{}", enc_width, enc_height);
    println!("Frames encoded:     {}", stats.frames_encoded);
    println!("Total time:         {:.2}s", stats.elapsed_secs);
    println!("Output:             {}", stats.output_path);
    if stats.import_failures > 0 {
        println!("Import failures:    {}", stats.import_failures);
    }
    println!(
        "import avg:         {:.2} ms/frame",
        FrameStats::avg_ms(&stats.import_us)
    );
    if !stats.filter_us.is_empty() {
        println!(
            "filter avg:         {:.2} ms/frame",
            FrameStats::avg_ms(&stats.filter_us)
        );
    }
    println!(
        "transfer avg:       {:.2} ms/frame",
        FrameStats::avg_ms(&stats.transfer_us)
    );
    if !stats.scale_us.is_empty() {
        println!(
            "scale avg:          {:.2} ms/frame",
            FrameStats::avg_ms(&stats.scale_us)
        );
    }
    if !stats.format_us.is_empty() {
        println!(
            "format avg:         {:.2} ms/frame",
            FrameStats::avg_ms(&stats.format_us)
        );
    }
    println!(
        "encode ({}):        {:.2} ms/frame",
        stats.codec_name,
        FrameStats::avg_ms(&stats.encode_us)
    );
    println!("total avg:          {:.2} ms/frame", stats.avg_total_ms());
    println!("achieved FPS:       {:.1}", stats.achieved_fps());
    println!("max theoretical:    {:.1} FPS", stats.theoretical_fps());
}

fn print_comparison(cpu: Option<&FrameStats>, gpu: Option<&FrameStats>) {
    println!();
    println!("=== Pipeline Comparison ===");
    if let Some(s) = cpu {
        println!(
            "CPU: import={:.2}ms transfer={:.2}ms scale={:.2}ms encode={:.2}ms total={:.2}ms ({:.1} FPS)",
            FrameStats::avg_ms(&s.import_us),
            FrameStats::avg_ms(&s.transfer_us),
            FrameStats::avg_ms(&s.scale_us),
            FrameStats::avg_ms(&s.encode_us),
            s.avg_total_ms(),
            s.theoretical_fps(),
        );
    }
    if let Some(s) = gpu {
        println!(
            "GPU: import={:.2}ms filter={:.2}ms transfer={:.2}ms format={:.2}ms encode={:.2}ms total={:.2}ms ({:.1} FPS)",
            FrameStats::avg_ms(&s.import_us),
            FrameStats::avg_ms(&s.filter_us),
            FrameStats::avg_ms(&s.transfer_us),
            FrameStats::avg_ms(&s.format_us),
            FrameStats::avg_ms(&s.encode_us),
            s.avg_total_ms(),
            s.theoretical_fps(),
        );
    }
}

fn main() -> Result<()> {
    let bench_args = BenchArgs::parse();

    println!("=== VAAPI Import Benchmark ===");
    println!("Output: {}", bench_args.output);
    println!("Target frames: {}", bench_args.frames);
    println!(
        "Encode resolution: {}x{}",
        bench_args.enc_width, bench_args.enc_height
    );
    println!("DRM device: {}", bench_args.drm_device);
    println!();

    ff::init()?;

    println!("[1/3] Requesting screen capture via XDG Portal...");
    println!("       (Select a screen to share in the portal dialog)");

    let portal_args = Args {
        output: Some(bench_args.output.clone()),
        output_name: None,
        fps: 60,
        codec: "h264".to_string(),
        hw_accel: "vaapi".to_string(),
        drm_device: None,
        bitrate: None,
        max_bitrate: 8_000_000,
        gop_size: None,
        verbose: false,
        backend: Some("portal".to_string()),
        port: 0,
        no_persist: false,
        stats: false,
    };

    let cap = CapPortal::new(&portal_args)?;
    println!("[1/3] Portal connected, PipeWire stream active\n");

    println!("[2/3] Waiting for first frame from PipeWire...");
    let first_frame = receive_first_frame(&cap)?;

    let src_width = first_frame.width;
    let src_height = first_frame.height;
    let src_format = first_frame.format;

    println!(
        "[2/3] First frame: {}x{}, format=0x{:08X}, stride={}, modifier=0x{:X}",
        src_width, src_height, src_format, first_frame.stride, first_frame.modifier
    );

    println!("\n[2/3] Testing av_hwframe_map with sw_format=BGRA...");
    println!(
        "       DRM format chain: PipeWire BGRA -> DRM_FORMAT_ARGB8888 (0x{:08X}) -> VA_FOURCC_BGRA -> AV_PIX_FMT_BGRA",
        src_format
    );

    let drm_device = Path::new(&bench_args.drm_device);
    let hw_dev = AvHwDevCtx::new_vaapi(drm_device)?;
    println!("       VAAPI device context created OK");

    let frames_ctx =
        AvHwFrameCtx::for_capture(&hw_dev, src_width, src_height, ff::format::Pixel::BGRA)?;
    println!("       VAAPI frames context created OK (sw_format=BGRA)");

    let vaapi_frame = unsafe {
        import_dma_buf_to_vaapi(
            frames_ctx.as_ptr(),
            first_frame.fd.as_raw_fd(),
            first_frame.width,
            first_frame.height,
            first_frame.format,
            first_frame.modifier,
            first_frame.stride,
            first_frame.offset,
        )
    };

    match &vaapi_frame {
        Ok(_) => {
            println!("       Result: SUCCESS — av_hwframe_map imported DMA-BUF to VAAPI surface!");
        }
        Err(e) => {
            println!("       Result: FAILED");
            println!("       Error: {e}");
            println!();
            println!("       Possible causes:");
            println!("       - sw_format mismatch (current: BGRA)");
            println!("       - DRM format modifier not supported by VAAPI");
            println!("       - VAAPI driver doesn't support DMA-BUF import for this format");
            println!();
            println!("       Falling back to mmap readback test for comparison...");

            let mmap_size = (first_frame.stride as usize) * (first_frame.height as usize);
            let mmap_start = Instant::now();
            let mmap_ptr = unsafe {
                libc::mmap(
                    ptr::null_mut(),
                    mmap_size,
                    libc::PROT_READ,
                    libc::MAP_SHARED,
                    first_frame.fd.as_raw_fd(),
                    first_frame.offset as i64,
                )
            };
            let mmap_elapsed = mmap_start.elapsed();

            if mmap_ptr == libc::MAP_FAILED {
                let errno = std::io::Error::last_os_error();
                println!("       mmap also FAILED: {errno}");
            } else {
                println!(
                    "       mmap SUCCESS: {:.1} MB, setup in {:.2}ms",
                    mmap_size as f64 / 1024.0 / 1024.0,
                    mmap_elapsed.as_secs_f64() * 1000.0
                );
                unsafe {
                    libc::munmap(mmap_ptr, mmap_size);
                }
            }

            println!();
            println!("=== Benchmark ended: av_hwframe_map import FAILED ===");
            println!("Fix the import issue before proceeding to GPU downscale tests.");
            return Ok(());
        }
    }

    drop(vaapi_frame);
    drop(first_frame);

    println!("\n[3/3] Benchmarking selected pipeline(s)...");

    let enc_width = bench_args.enc_width;
    let enc_height = bench_args.enc_height;
    let split_outputs = bench_args.mode == PipelineMode::Both;
    let mut cpu_stats = None;
    let mut gpu_stats = None;

    if matches!(bench_args.mode, PipelineMode::Cpu | PipelineMode::Both) {
        let output = output_for_mode(&bench_args.output, PipelineMode::Cpu, split_outputs);
        cpu_stats = Some(run_cpu_pipeline(
            &cap,
            &frames_ctx,
            &output,
            bench_args.frames,
            src_width,
            src_height,
            enc_width,
            enc_height,
        )?);
    }

    if matches!(bench_args.mode, PipelineMode::Gpu | PipelineMode::Both) {
        let output = output_for_mode(&bench_args.output, PipelineMode::Gpu, split_outputs);
        gpu_stats = Some(run_gpu_pipeline(
            &cap,
            &hw_dev,
            &frames_ctx,
            &output,
            bench_args.frames,
            src_width,
            src_height,
            enc_width,
            enc_height,
        )?);
    }

    if let Some(stats) = cpu_stats.as_ref() {
        print_detailed_results("CPU", stats, src_width, src_height, enc_width, enc_height);
    }
    if let Some(stats) = gpu_stats.as_ref() {
        print_detailed_results("GPU", stats, src_width, src_height, enc_width, enc_height);
    }
    print_comparison(cpu_stats.as_ref(), gpu_stats.as_ref());

    if cpu_stats
        .as_ref()
        .into_iter()
        .chain(gpu_stats.as_ref())
        .any(|stats| stats.achieved_fps() < 30.0 && stats.frames_encoded > 0)
    {
        println!("NOTE: At least one achieved FPS result is below 30 FPS target.");
    }
    Ok(())
}