// 硬件设备类型枚举
typedef enum AVHWDeviceType {
    AV_HWDEVICE_TYPE_NONE,
    AV_HWDEVICE_TYPE_VDPAU,        // Linux NVIDIA (旧)
    AV_HWDEVICE_TYPE_CUDA,         // NVIDIA NVDEC
    AV_HWDEVICE_TYPE_VAAPI,        // Linux Intel/AMD
    AV_HWDEVICE_TYPE_DXVA2,        // Windows
    AV_HWDEVICE_TYPE_QSV,          // Intel QuickSync
    AV_HWDEVICE_TYPE_VIDEOTOOLBOX, // macOS/iOS
    AV_HWDEVICE_TYPE_D3D11VA,      // Windows
    AV_HWDEVICE_TYPE_DRM,          // Linux DRM
    AV_HWDEVICE_TYPE_OPENCL,
    AV_HWDEVICE_TYPE_MEDIACODEC,   // Android
} AVHWDeviceType;

#include <libavcodec/avcodec.h>
#include <libavutil/hwcontext.h>
#include <libavutil/pixdesc.h>
#include <iostream>

class VideoToolboxDecoder {
public:
    bool Init(AVCodecID codec_id) {
        // 1. 查找硬件解码器
        const char* decoder_name = nullptr;
        if (codec_id == AV_CODEC_ID_H264) {
            decoder_name = "h264_videotoolbox";
        } else if (codec_id == AV_CODEC_ID_HEVC) {
            decoder_name = "hevc_videotoolbox";
        } else {
            std::cerr << "[VideoToolbox] Unsupported codec" << std::endl;
            return false;
        }
        
        codec_ = avcodec_find_decoder_by_name(decoder_name);
        if (!codec_) {
            std::cerr << "[VideoToolbox] Decoder not found: " << decoder_name << std::endl;
            return false;
        }
        
        // 2. 创建硬件设备上下文
        int ret = av_hwdevice_ctx_create(
            &hw_device_ctx_,
            AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
            nullptr, nullptr, 0);
        if (ret < 0) {
            char errbuf[256];
            av_strerror(ret, errbuf, sizeof(errbuf));
            std::cerr << "[VideoToolbox] Failed to create device: " << errbuf << std::endl;
            return false;
        }
        
        // 3. 创建解码器上下文
        ctx_ = avcodec_alloc_context3(codec_);
        if (!ctx_) {
            std::cerr << "[VideoToolbox] Failed to allocate context" << std::endl;
            return false;
        }
        
        ctx_>hw_device_ctx = av_buffer_ref(hw_device_ctx_);
        
        // 4. 打开解码器
        ret = avcodec_open2(ctx_, codec_, nullptr);
        if (ret < 0) {
            char errbuf[256];
            av_strerror(ret, errbuf, sizeof(errbuf));
            std::cerr << "[VideoToolbox] Failed to open codec: " << errbuf << std::endl;
            return false;
        }
        
        std::cout << "[VideoToolbox] Decoder initialized: " << decoder_name << std::endl;
        return true;
    }
    
    AVFrame* Decode(AVPacket* pkt) {
        int ret = avcodec_send_packet(ctx_, pkt);
        if (ret < 0) {
            return nullptr;
        }
        
        AVFrame* frame = av_frame_alloc();
        ret = avcodec_receive_frame(ctx_, frame);
        if (ret < 0) {
            av_frame_free(&frame);
            return nullptr;
        }
        
        // frame->format 可能是 AV_PIX_FMT_VIDEOTOOLBOX
        // 表示数据在 GPU 显存中（CVPixelBuffer）
        return frame;
    }
    
    // 将 GPU 帧转移到系统内存
    AVFrame* TransferToSystemMemory(AVFrame* hw_frame) {
        if (hw_frame->format != AV_PIX_FMT_VIDEOTOOLBOX) {
            // 已经在系统内存
            return hw_frame;
        }
        
        AVFrame* sw_frame = av_frame_alloc();
        int ret = av_hwframe_transfer_data(sw_frame, hw_frame, 0);
        if (ret < 0) {
            av_frame_free(&sw_frame);
            return nullptr;
        }
        
        av_frame_copy_props(sw_frame, hw_frame);
        return sw_frame;
    }
    
    ~VideoToolboxDecoder() {
        if (ctx_) {
            avcodec_free_context(&ctx_);
        }
        if (hw_device_ctx_) {
            av_buffer_unref(&hw_device_ctx_);
        }
    }

private:
    const AVCodec* codec_ = nullptr;
    AVCodecContext* ctx_ = nullptr;
    AVBufferRef* hw_device_ctx_ = nullptr;
};

# 安装驱动
sudo apt install intel-media-va-driver vainfo

# 验证
vainfo
# 应显示 VAProfileH264High 等配置

sudo apt install mesa-va-drivers vainfo

#include <libavcodec/avcodec.h>
#include <libavutil/hwcontext.h>
#include <iostream>

class VAAPIDecoder {
public:
    bool Init(AVCodecID codec_id, const std::string& device = "") {
        // 1. 选择解码器
        const char* decoder_name = nullptr;
        if (codec_id == AV_CODEC_ID_H264) {
            decoder_name = "h264_vaapi";
        } else if (codec_id == AV_CODEC_ID_HEVC) {
            decoder_name = "hevc_vaapi";
        } else {
            return false;
        }
        
        codec_ = avcodec_find_decoder_by_name(decoder_name);
        if (!codec_) {
            std::cerr << "[VAAPI] Decoder not found: " << decoder_name << std::endl;
            return false;
        }
        
        // 2. 创建 VAAPI 设备上下文
        // device 可以是 "/dev/dri/renderD128" 或空（自动选择）
        int ret = av_hwdevice_ctx_create(
            &hw_device_ctx_,
            AV_HWDEVICE_TYPE_VAAPI,
            device.empty() ? nullptr : device.c_str(),
            nullptr, 0);
        if (ret < 0) {
            char errbuf[256];
            av_strerror(ret, errbuf, sizeof(errbuf));
            std::cerr << "[VAAPI] Failed to create device: " << errbuf << std::endl;
            return false;
        }
        
        // 3. 创建解码器上下文
        ctx_ = avcodec_alloc_context3(codec_);
        ctx_>hw_device_ctx = av_buffer_ref(hw_device_ctx_);
        
        // 4. 打开解码器
        ret = avcodec_open2(ctx_, codec_, nullptr);
        if (ret < 0) {
            std::cerr << "[VAAPI] Failed to open codec" << std::endl;
            return false;
        }
        
        std::cout << "[VAAPI] Decoder initialized on " << 
            (device.empty() ? "default device" : device) << std::endl;
        return true;
    }
    
    ~VAAPIDecoder() {
        if (ctx_) avcodec_free_context(&ctx_);
        if (hw_device_ctx_) av_buffer_unref(&hw_device_ctx_);
    }

private:
    const AVCodec* codec_ = nullptr;
    AVCodecContext* ctx_ = nullptr;
    AVBufferRef* hw_device_ctx_ = nullptr;
};

// 列出可用设备
std::vector<std::string> ListVAAPIDevices() {
    std::vector<std::string> devices;
    for (int i = 0; i < 10; i++) {
        std::string path = "/dev/dri/renderD" + std::to_string(128 + i);
        if (access(path.c_str(), F_OK) == 0) {
            devices.push_back(path);
        }
    }
    return devices;
}

#include <libavcodec/avcodec.h>
#include <libavutil/hwcontext.h>
#include <iostream>

class NVDECDecoder {
public:
    bool Init(AVCodecID codec_id, int gpu_id = 0) {
        // 1. 选择解码器
        const char* decoder_name = nullptr;
        switch (codec_id) {
            case AV_CODEC_ID_H264:  decoder_name = "h264_nvdec"; break;
            case AV_CODEC_ID_HEVC:  decoder_name = "hevc_nvdec"; break;
            case AV_CODEC_ID_VP9:   decoder_name = "vp9_nvdec"; break;
            case AV_CODEC_ID_AV1:   decoder_name = "av1_nvdec"; break;
            default:
                std::cerr << "[NVDEC] Unsupported codec" << std::endl;
                return false;
        }
        
        codec_ = avcodec_find_decoder_by_name(decoder_name);
        if (!codec_) {
            std::cerr << "[NVDEC] Decoder not found: " << decoder_name << std::endl;
            return false;
        }
        
        // 2. 创建 CUDA 设备上下文
        // gpu_id: 0 = 第一块 GPU, 1 = 第二块...
        char device_str[32];
        snprintf(device_str, sizeof(device_str), "%d", gpu_id);
        
        int ret = av_hwdevice_ctx_create(
            &hw_device_ctx_,
            AV_HWDEVICE_TYPE_CUDA,
            device_str, nullptr, 0);
        if (ret < 0) {
            char errbuf[256];
            av_strerror(ret, errbuf, sizeof(errbuf));
            std::cerr << "[NVDEC] Failed to create CUDA device: " << errbuf << std::endl;
            return false;
        }
        
        // 3. 创建解码器上下文
        ctx_ = avcodec_alloc_context3(codec_);
        ctx_>hw_device_ctx = av_buffer_ref(hw_device_ctx_);
        
        // 4. 打开解码器
        ret = avcodec_open2(ctx_, codec_, nullptr);
        if (ret < 0) {
            std::cerr << "[NVDEC] Failed to open codec" << std::endl;
            return false;
        }
        
        std::cout << "[NVDEC] Decoder initialized on GPU " << gpu_id << std::endl;
        return true;
    }
    
    ~NVDECDecoder() {
        if (ctx_) avcodec_free_context(&ctx_);
        if (hw_device_ctx_) av_buffer_unref(&hw_device_ctx_);
    }

private:
    const AVCodec* codec_ = nullptr;
    AVCodecContext* ctx_ = nullptr;
    AVBufferRef* hw_device_ctx_ = nullptr;
};

// include/live/hardware_decoder.h
#pragma once
#include <string>
#include <memory>

extern "C" {
#include <libavcodec/avcodec.h>
}

namespace live {

enum class HWDecoderType {
    Auto,           // 自动选择
    Software,       // 强制软件解码
    VideoToolbox,   // macOS
    VAAPI,          // Linux Intel/AMD
    NVDEC,          // Linux/Windows NVIDIA
    DXVA,           // Windows
    MediaCodec,     // Android
};

struct HWDecoderConfig {
    HWDecoderType type = HWDecoderType::Auto;
    std::string device;  // VAAPI 设备路径或 GPU ID
    int width = 1920;
    int height = 1080;
};

class HardwareDecoder {
public:
    explicit HardwareDecoder(const HWDecoderConfig& config);
    ~HardwareDecoder();

    // 禁止拷贝
    HardwareDecoder(const HardwareDecoder&) = delete;
    HardwareDecoder& operator=(const HardwareDecoder&) = delete;

    // 初始化解码器
    bool Init(AVCodecID codec_id);
    
    // 解码一帧
    // 返回的 AVFrame 需要用 av_frame_free 释放
    AVFrame* Decode(AVPacket* pkt);
    
    // 获取解码器信息
    bool IsHardware() const { return is_hardware_; }
    HWDecoderType GetActualType() const { return actual_type_; }
    int GetWidth() const { return ctx_ ? ctx_>width : 0; }
    int GetHeight() const { return ctx_ ? ctx_>height : 0; }

private:
    bool TryInitVideoToolbox(AVCodecID codec_id);
    bool TryInitNVDEC(AVCodecID codec_id);
    bool TryInitVAAPI(AVCodecID codec_id);
    bool TryInitSoftware(AVCodecID codec_id);
    
    AVFrame* TransferHWToSW(AVFrame* hw_frame);
    
    HWDecoderConfig config_;
    HWDecoderType actual_type_ = HWDecoderType::Software;
    
    const AVCodec* codec_ = nullptr;
    AVCodecContext* ctx_ = nullptr;
    AVBufferRef* hw_device_ctx_ = nullptr;
    bool is_hardware_ = false;
};

} // namespace live

// src/hardware_decoder.cpp
#include "live/hardware_decoder.h"
#include <iostream>

namespace live {

HardwareDecoder::HardwareDecoder(const HWDecoderConfig& config)
    : config_(config) {
}

HardwareDecoder::~HardwareDecoder() {
    if (ctx_) {
        // 冲刷解码器
        avcodec_send_packet(ctx_, nullptr);
        AVFrame* frame = av_frame_alloc();
        while (avcodec_receive_frame(ctx_, frame) >= 0) {
            av_frame_unref(frame);
        }
        av_frame_free(&frame);
        
        avcodec_free_context(&ctx_);
    }
    if (hw_device_ctx_) {
        av_buffer_unref(&hw_device_ctx_);
    }
}

bool HardwareDecoder::Init(AVCodecID codec_id) {
    // 如果强制软件解码
    if (config_.type == HWDecoderType::Software) {
        return TryInitSoftware(codec_id);
    }
    
    // 尝试指定的硬件解码器
    if (config_.type == HWDecoderType::VideoToolbox) {
        if (TryInitVideoToolbox(codec_id)) return true;
    } else if (config_.type == HWDecoderType::NVDEC) {
        if (TryInitNVDEC(codec_id)) return true;
    } else if (config_.type == HWDecoderType::VAAPI) {
        if (TryInitVAAPI(codec_id)) return true;
    }
    
    // 自动选择：按优先级尝试
    if (config_.type == HWDecoderType::Auto) {
        // 优先级：NVDEC > VideoToolbox > VAAPI
        if (TryInitNVDEC(codec_id)) return true;
        if (TryInitVideoToolbox(codec_id)) return true;
        if (TryInitVAAPI(codec_id)) return true;
    }
    
    // 所有硬件解码器失败，回退到软件解码
    std::cout << "[HardwareDecoder] All hardware decoders failed, fallback to software" << std::endl;
    return TryInitSoftware(codec_id);
}

bool HardwareDecoder::TryInitVideoToolbox(AVCodecID codec_id) {
#if defined(__APPLE__)
    const char* name = (codec_id == AV_CODEC_ID_H264) ? "h264_videotoolbox" : 
                       (codec_id == AV_CODEC_ID_HEVC) ? "hevc_videotoolbox" : nullptr;
    if (!name) return false;
    
    codec_ = avcodec_find_decoder_by_name(name);
    if (!codec_) return false;
    
    if (av_hwdevice_ctx_create(&hw_device_ctx_, AV_HWDEVICE_TYPE_VIDEOTOOLBOX, 
                               nullptr, nullptr, 0) < 0) {
        return false;
    }
    
    ctx_ = avcodec_alloc_context3(codec_);
    ctx_>hw_device_ctx = av_buffer_ref(hw_device_ctx_);
    
    if (avcodec_open2(ctx_, codec_, nullptr) < 0) {
        avcodec_free_context(&ctx_);
        return false;
    }
    
    is_hardware_ = true;
    actual_type_ = HWDecoderType::VideoToolbox;
    std::cout << "[HardwareDecoder] Using VideoToolbox" << std::endl;
    return true;
#else
    return false;
#endif
}

bool HardwareDecoder::TryInitNVDEC(AVCodecID codec_id) {
    const char* name = nullptr;
    switch (codec_id) {
        case AV_CODEC_ID_H264: name = "h264_nvdec"; break;
        case AV_CODEC_ID_HEVC: name = "hevc_nvdec"; break;
        case AV_CODEC_ID_VP9:  name = "vp9_nvdec"; break;
        case AV_CODEC_ID_AV1:  name = "av1_nvdec"; break;
        default: return false;
    }
    
    codec_ = avcodec_find_decoder_by_name(name);
    if (!codec_) return false;
    
    const char* device = config_.device.empty() ? nullptr : config_.device.c_str();
    if (av_hwdevice_ctx_create(&hw_device_ctx_, AV_HWDEVICE_TYPE_CUDA, 
                               device, nullptr, 0) < 0) {
        return false;
    }
    
    ctx_ = avcodec_alloc_context3(codec_);
    ctx_>hw_device_ctx = av_buffer_ref(hw_device_ctx_);
    
    if (avcodec_open2(ctx_, codec_, nullptr) < 0) {
        avcodec_free_context(&ctx_);
        return false;
    }
    
    is_hardware_ = true;
    actual_type_ = HWDecoderType::NVDEC;
    std::cout << "[HardwareDecoder] Using NVDEC" << std::endl;
    return true;
}

bool HardwareDecoder::TryInitVAAPI(AVCodecID codec_id) {
    const char* name = (codec_id == AV_CODEC_ID_H264) ? "h264_vaapi" : 
                       (codec_id == AV_CODEC_ID_HEVC) ? "hevc_vaapi" : nullptr;
    if (!name) return false;
    
    codec_ = avcodec_find_decoder_by_name(name);
    if (!codec_) return false;
    
    const char* device = config_.device.empty() ? nullptr : config_.device.c_str();
    if (av_hwdevice_ctx_create(&hw_device_ctx_, AV_HWDEVICE_TYPE_VAAPI, 
                               device, nullptr, 0) < 0) {
        return false;
    }
    
    ctx_ = avcodec_alloc_context3(codec_);
    ctx_>hw_device_ctx = av_buffer_ref(hw_device_ctx_);
    
    if (avcodec_open2(ctx_, codec_, nullptr) < 0) {
        avcodec_free_context(&ctx_);
        return false;
    }
    
    is_hardware_ = true;
    actual_type_ = HWDecoderType::VAAPI;
    std::cout << "[HardwareDecoder] Using VAAPI" << std::endl;
    return true;
}

bool HardwareDecoder::TryInitSoftware(AVCodecID codec_id) {
    codec_ = avcodec_find_decoder(codec_id);
    if (!codec_) return false;
    
    ctx_ = avcodec_alloc_context3(codec_);
    
    // 启用多线程软解
    ctx_>thread_count = 4;
    ctx_>thread_type = FF_THREAD_FRAME;
    
    if (avcodec_open2(ctx_, codec_, nullptr) < 0) {
        avcodec_free_context(&ctx_);
        return false;
    }
    
    is_hardware_ = false;
    actual_type_ = HWDecoderType::Software;
    std::cout << "[HardwareDecoder] Using software decoder" << std::endl;
    return true;
}

AVFrame* HardwareDecoder::Decode(AVPacket* pkt) {
    if (!ctx_) return nullptr;
    
    int ret = avcodec_send_packet(ctx_, pkt);
    if (ret < 0 && ret != AVERROR_EOF) {
        return nullptr;
    }
    
    AVFrame* frame = av_frame_alloc();
    ret = avcodec_receive_frame(ctx_, frame);
    if (ret < 0) {
        av_frame_free(&frame);
        return nullptr;
    }
    
    // 如果是硬件帧，转移到系统内存
    if (is_hardware_ && frame->format != AV_PIX_FMT_YUV420P) {
        AVFrame* sw_frame = TransferHWToSW(frame);
        av_frame_free(&frame);
        return sw_frame;
    }
    
    return frame;
}

AVFrame* HardwareDecoder::TransferHWToSW(AVFrame* hw_frame) {
    AVFrame* sw_frame = av_frame_alloc();
    if (av_hwframe_transfer_data(sw_frame, hw_frame, 0) < 0) {
        av_frame_free(&sw_frame);
        return nullptr;
    }
    av_frame_copy_props(sw_frame, hw_frame);
    return sw_frame;
}

} // namespace live

// VideoToolbox 解码输出 CVPixelBuffer
CVPixelBufferRef pixel_buffer = (CVPixelBufferRef)frame->data[3];

// 创建 Metal 纹理
CVMetalTextureRef metal_texture;
CVMetalTextureCacheCreateTextureFromImage(
    nullptr, texture_cache, pixel_buffer, nullptr,
    MTLPixelFormatBGRA8Unorm, width, height, 0, &metal_texture);

// 直接渲染

// VAAPI 输出 VA 表面
VASurfaceID surface = (VASurfaceID)(uintptr_t)frame->data[3];

// 使用 EGL 创建纹理
// 需要 EGL_EXT_image_dma_buf_import 扩展

class AdaptiveDecoder {
public:
    AVFrame* Decode(AVPacket* pkt) {
        if (hw_decoder_ && !force_software_) {
            AVFrame* frame = hw_decoder_>Decode(pkt);
            if (frame) return frame;
            
            // 硬件解码失败
            hardware_failures_++;
            if (hardware_failures_ >= MAX_FAILURES) {
                std::cout << "Switching to software decoder" << std::endl;
                force_software_ = true;
            }
        }
        
        return sw_decoder_>Decode(pkt);
    }

private:
    static const int MAX_FAILURES = 10;
    int hardware_failures_ = 0;
    bool force_software_ = false;
};

./hw-player rtmp://server/4k-stream
# 4K 流畅播放，CPU 占用 < 15%