工业相机高速回调与异步处理：海康 C++ 实战代码

2. 实现线程安全环形缓冲队列

注：此处使用 std::mutex + std::condition_variable 实现有界阻塞队列，生产环境可根据需求优化为无锁 RingBuffer。

#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>

template<typename T>
class RingBuffer {
private:
    std::queue<T> queue_;
    mutable std::mutex mutex_;
    std::condition_variable notFull_;
    std::condition_variable notEmpty_;
    const size_t capacity_;

public:
    explicit RingBuffer(size_t capacity) : capacity_(capacity) {}

    // 生产者调用：阻塞式入队
    void enqueue(T item) {
        std::unique_lock<std::mutex> lock(mutex_);
        notFull_.wait(lock, [this]() { return queue_.size() < capacity_; });
        queue_.push(std::move(item));
        notEmpty_.notify_one();
    }

    // 消费者调用：阻塞式出队
    T dequeue() {
        std::unique_lock<std::mutex> lock(mutex_);
        notEmpty_.wait(lock, [this]() { return !queue_.empty(); });
        T item = std::move(queue_.front());
        queue_.pop();
        notFull_.notify_one();
        return item;
    }

    // 非阻塞尝试出队（用于退出逻辑）
    bool tryDequeue(T& item) {
        std::unique_lock<std::mutex> lock(mutex_);
        if (queue_.empty()) {
            return false;
        }
        item = std::move(queue_.front());
        queue_.pop();
        notFull_.notify_one();
        return true;
    }

    void clear() {
        std::unique_lock<std::mutex> lock(mutex_);
        while (!queue_.empty()) {
            queue_.pop();
        }
        notFull_.notify_all();
    }
};

3. 高速存储服务类（HighSpeedRecorder）

#include <fstream>
#include <filesystem>
#include <atomic>

namespace fs = std::filesystem;

class HighSpeedRecorder {
private:
    RingBuffer<ImageFrame> ringBuffer_;
    std::thread writerThread_;
    std::atomic<bool> isRunning_;
    std::string outputDir_;

    void writerLoop() {
        while (isRunning_) {
            ImageFrame frame = ringBuffer_.dequeue();
            saveFrame(frame);
        }
        // 清空剩余帧
        ImageFrame frame;
        while (ringBuffer_.tryDequeue(frame)) {
            saveFrame(frame);
        }
    }

    void saveFrame(const ImageFrame& frame) {
        std::string fileName = "frame_" + std::to_string(frame.timestampUs) + ".bin";
        std::string path = fs::path(outputDir_) / fileName;
        std::ofstream ofs(path, std::ios::binary | std::ios::out);
        if (ofs.is_open()) {
            ofs.write(reinterpret_cast<const char*>(frame.data.data()), frame.data.size());
        }
        // 可扩展：LZ4 压缩、转 TIFF、添加元数据等
    }

public:
    HighSpeedRecorder(const std::string& outputDir, size_t bufferCapacity = 20)
        : ringBuffer_(bufferCapacity), isRunning_(false), outputDir_(outputDir) {
        fs::create_directories(outputDir);
    }

    ~HighSpeedRecorder() {
        stop();
    }

    // 生产者接口：由相机回调调用
    void onNewFrame(ImageFrame frame) {
        if (isRunning_) {
            ringBuffer_.enqueue(std::move(frame));
        }
    }

    void start() {
        isRunning_ = true;
        writerThread_ = std::thread(&HighSpeedRecorder::writerLoop, this);
    }

    void stop() {
        if (!isRunning_) return;
        isRunning_ = false;
        ringBuffer_.clear();
        // 唤醒等待中的消费者
        if (writerThread_.joinable()) {
            writerThread_.join();
        }
    }
};

4. 海康相机采集端集成（MVS SDK）

假设已链接 MvCameraControl.lib 并包含相应头文件

#include "MvCameraControl.h"
#include <cstring>

// 全局用户数据指针，用于传递 Recorder 实例
struct UserData {
    HighSpeedRecorder* recorder;
    bool isRunning;
    void* handle;
};

// 相机回调函数（运行在非主线程）
void __stdcall FrameCallback(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser) {
    UserData* userData = static_cast<UserData*>(pUser);
    if (!userData || !userData->isRunning || !userData->recorder) return;

    // 快速拷贝数据（避免持有 SDK 缓冲区过久）
    std::vector<uint8_t> frameData(pFrameInfo->nFrameLen);
    memcpy(frameData.data(), pData, pFrameInfo->nFrameLen);

    ImageFrame frame;
    frame.data = std::move(frameData);
    frame.width = pFrameInfo->nWidth;
    frame.height = pFrameInfo->nHeight;

    // 合并高低位时间戳
    frame.timestampUs = ((uint64_t)pFrameInfo->nTimeStampHigh << 32) | pFrameInfo->nTimeStampLow;
    frame.cameraId = "Hikvision";

    // 入队（毫秒级完成）
    userData->recorder->onNewFrame(std::move(frame));

    // 【关键】必须释放 SDK 缓冲区！否则内存泄漏
    MV_CC_FreeImageBuffer(userData->handle, pData);
}

class HikvisionFrameGrabber {
private:
    void* handle_;
    UserData userData_;
    std::unique_ptr<HighSpeedRecorder> recorder_;
    bool isRunning_;

public:
    HikvisionFrameGrabber(const std::string& outputDir, const std::string& deviceIp)
        : handle_(nullptr), isRunning_(false) {
        recorder_ = std::make_unique<HighSpeedRecorder>(outputDir, 20);
        userData_.recorder = recorder_.get();
        userData_.isRunning = false;
        userData_.handle = nullptr;

        // 创建句柄
        MV_CC_CreateHandle(&handle_, MV_GIGE_DEVICE, nullptr);

        // 打开设备（IP 方式示例）
        MV_NETTRANS_CONFIG stNetTransConfig;
        memset(&stNetTransConfig, 0, sizeof(MV_NETTRANS_CONFIG));
        strncpy((char*)stNetTransConfig.nDeviceIP, deviceIp.c_str(), 16);
        stNetTransConfig.nDevicePort = 8000;
        stNetTransConfig.nGigEIpOption = 0;
        MV_CC_OpenDevice(handle_, &stNetTransConfig);

        // 设置取流模式等参数（略）
        MV_CC_SetEnumValue(handle_, "AcquisitionMode", 2); // Continuous
    }

    ~HikvisionFrameGrabber() {
        stop();
        if (handle_) {
            MV_CC_CloseDevice(handle_);
            MV_CC_DestroyHandle(handle_);
        }
    }

    void start() {
        recorder_->start();
        isRunning_ = true;
        userData_.isRunning = true;
        userData_.handle = handle_;

        // 注册回调函数（非阻塞）
        MV_CC_RegisterImageCallBackEx(handle_, FrameCallback, &userData_);

        // 开始取流
        MV_CC_StartGrabbing(handle_);
    }

    void stop() {
        if (!isRunning_) return;
        isRunning_ = false;
        userData_.isRunning = false;
        MV_CC_StopGrabbing(handle_);
        recorder_->stop();
    }
};

四、性能优化与避坑指南

进阶优化技巧

1. 内存池复用：避免频繁 new/delete 或 vector 重分配，使用 boost::pool 或自定义对象池复用 ImageFrame；
2. 零拷贝优化：若 SDK 支持，可直接传递指针并在消费者端处理，但需严格管理生命周期；
3. 异步 I/O：使用 io_uring (Linux) 或 IOCP (Windows) 提升磁盘写入吞吐量；
4. 批量写入：消费者线程可累积多帧后一次性写入，减少 syscall 次数；
5. CPU 亲和性：将采集线程和写入线程绑定到不同 CPU 核心，减少缓存失效。

海康 SDK 五大致命陷阱

五、实测效果对比（4K@60fps, RAW 12MB/帧）

结论：合理架构让系统真正跑满相机极限帧率！

六、总结

高速图像存储的黄金法则：

'回调只入队，绝不碰磁盘' '内存要预分配，运行少 new' '写入单线程，批量更高效'

通过生产者 - 消费者模型与环形缓冲队列，我们成功将图像采集与磁盘 I/O 解耦，不仅解决了丢帧难题，更实现了内存稳定、扩展性强的工业级方案。

无论是海康、Basler 还是堡盟相机，这套 C++ 架构均可无缝适配。只需替换 SDK 调用部分，核心逻辑通用！