C++多相机帧同步图像缓冲区性能优化咨询

核心问题定位 #

当前代码存在两个致命问题直接导致帧率低下：

1. CaptureThread未真正创建并行线程：start()函数直接调用run()，导致三个相机的帧读取逻辑串行执行，单相机30fps的情况下，三相机串行后帧率自然降至10fps。
2. BufferManager同步逻辑阻塞相机读取：每个线程在提交帧后需等待其他相机的帧到达，无法持续读取相机缓冲区，导致相机帧可能堆积或丢失，同时锁竞争加剧。

以下是具体优化建议：

1. 修复CaptureThread的线程创建逻辑 #

当前代码未真正启动并行线程，需封装std::thread实现多线程并行读取：

class CaptureThread
{
public:
    CaptureThread(const Camera& camera) : camera_(camera) {}

    void start()
    {
        continue_thread_ = true;
        // 创建独立线程执行帧读取逻辑
        thread_ = std::thread(&CaptureThread::run, this);
    }

    void stop()
    {
        continue_thread_ = false;
        if (thread_.joinable())
        {
            thread_.join();
        }
    }

    void attachBufferManager(const std::shared_ptr<BufferManager>& buffer_manager)
    {
        buffer_manager_ = buffer_manager;
    }

private:
    void run()
    {
        while (continue_thread_)
        {
            if (camera_.img_buffer->read(frame_))
            {
                buffer_manager_->writeFrame(camera_, frame_);
            }
            else
            {
                // 无帧时短休眠，避免CPU空转
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
            }
        }
    }

    cv::Mat frame_;
    bool continue_thread_ = true;
    Camera camera_;
    std::shared_ptr<BufferManager> buffer_manager_;
    std::thread thread_; // 新增线程成员
};

2. 重构BufferManager的同步逻辑 #

原逻辑会阻塞相机读取线程，改为异步收集帧+非阻塞同步，让每个相机线程持续读取帧，BufferManager负责凑齐同步帧：

class BufferManager
{
public:
    BufferManager(int buffer_size) : buffer_size_(buffer_size), num_cameras_(3)
    {
        // 初始化固定相机的帧存储（避免字符串哈希开销）
        latest_frames["right"] = cv::Mat();
        latest_frames["left"] = cv::Mat();
        latest_frames["back"] = cv::Mat();
        frame_counters = {{"right", 0}, {"left", 0}, {"back", 0}};
    }

    void writeFrame(const Camera& camera, const cv::Mat& frame)
    {
        std::lock_guard<std::mutex> lock(mtx_);
        // 深拷贝帧，避免原数据被覆盖
        latest_frames[camera.name] = frame.clone();
        frame_counters[camera.name]++;

        // 检查是否所有相机都提交了新帧
        bool all_frames_ready = true;
        for (const auto& [name, cnt] : frame_counters)
        {
            if (cnt == 0)
            {
                all_frames_ready = false;
                break;
            }
        }

        if (all_frames_ready)
        {
            // 移动语义转移帧数据，避免拷贝开销
            std::unordered_map<std::string, cv::Mat> sync_group;
            for (auto& [name, mat] : latest_frames)
            {
                sync_group[name] = std::move(mat);
                frame_counters[name]--; // 标记该帧已被同步
            }

            // 维护缓冲区大小，避免内存溢出
            if (all_img_buffer_.size() >= buffer_size_)
            {
                all_img_buffer_.pop();
            }
            all_img_buffer_.push(std::move(sync_group));
            cv_.notify_all();
        }
    }

    bool read(std::unordered_map<std::string, cv::Mat>& sync_group)
    {
        std::unique_lock<std::mutex> lock(mtx_);
        // 等待直到有同步帧或停止信号
        cv_.wait(lock, [this]() { return !all_img_buffer_.empty() || !continue_running_; });
        
        if (all_img_buffer_.empty())
        {
            return false;
        }

        // 移动语义转移数据，减少拷贝
        sync_group = std::move(all_img_buffer_.front());
        all_img_buffer_.pop();
        return true;
    }

    void stop()
    {
        std::lock_guard<std::mutex> lock(mtx_);
        continue_running_ = false;
        cv_.notify_all();
    }

private:
    std::queue<std::unordered_map<std::string, cv::Mat>> all_img_buffer_;
    std::unordered_map<std::string, cv::Mat> latest_frames;
    std::unordered_map<std::string, int> frame_counters;
    int num_cameras_;
    std::condition_variable cv_;
    std::mutex mtx_;
    int buffer_size_;
    bool continue_running_ = true;
};

3. 优化显示线程的图像拼接性能 #

原cv::hconcat会产生两次中间数据拷贝，改为直接写入预分配的Mat，减少内存开销：

// 预先获取相机帧尺寸（假设三相机分辨率一致）
cv::Size frame_size;
bool first_run = true;
std::unordered_map<std::string, cv::Mat> all_imgs;
cv::Mat all_frame;

while (true)
{
    if (buffer_manager->read(all_imgs))
    {
        if (first_run)
        {
            frame_size = all_imgs["right"].size();
            // 预分配拼接后的图像内存
            all_frame.create(frame_size.height, frame_size.width * 3, all_imgs["right"].type());
            first_run = false;
        }

        // 直接拷贝帧到对应区域，避免中间拼接
        all_imgs["right"].copyTo(all_frame(cv::Rect(0, 0, frame_size.width, frame_size.height)));
        all_imgs["back"].copyTo(all_frame(cv::Rect(frame_size.width, 0, frame_size.width, frame_size.height)));
        all_imgs["left"].copyTo(all_frame(cv::Rect(frame_size.width * 2, 0, frame_size.width, frame_size.height)));

        cv::imshow("all_imgs", all_frame);
        if (cv::waitKey(1) == 'q')
        {
            break;
        }
    }
}

4. 进阶优化建议 #

• 替换字符串索引为枚举：用enum class CameraId { Right, Left, Back }代替字符串名称，结合std::array存储帧，避免字符串哈希开销，提升访问速度。
• 预分配相机帧内存：在CaptureThread中预先创建与相机分辨率匹配的cv::Mat，传递给read()函数，避免每次读取时的内存分配。
• 调整缓冲区大小：根据相机帧率和显示速度设置合适的buffer_size，建议设置为2-3，平衡内存占用和帧丢失风险。
• 检查相机读取性能：确认camera_.img_buffer->read()是否为阻塞式读取，若为非阻塞，可调整超时参数减少空转。

内容的提问来源于stack exchange，提问作者jlee