EncodingQueue.cpp

#include "EncodingQueue.h"

#include <utility>
#include <algorithm>

namespace vr_image_client
{

EncodingQueue::EncodingQueue(std::size_t max_size, std::size_t worker_count)
    : max_size_(max_size), worker_count_(std::max<std::size_t>(1, worker_count))
{
}

EncodingQueue::~EncodingQueue()
{
    Stop();
}

void EncodingQueue::Start()
{
    std::lock_guard<std::mutex> lock(mutex_);
    stop_requested_ = false;
    if (!workers_.empty())
    {
        return;
    }
    workers_.reserve(worker_count_);
    for (std::size_t i = 0; i < worker_count_; ++i)
    {
        workers_.emplace_back(&EncodingQueue::WorkerLoop, this);
    }
}

void EncodingQueue::Stop()
{
    {
        std::lock_guard<std::mutex> lock(mutex_);
        stop_requested_ = true;
    }
    cond_.notify_all();
    for (auto &worker : workers_)
    {
        if (worker.joinable())
        {
            worker.join();
        }
    }
    workers_.clear();
    std::lock_guard<std::mutex> lock(mutex_);
    queue_.clear();
}

void EncodingQueue::Enqueue(RawFrame frame, LogBuffer &logs)
{
    {
        std::lock_guard<std::mutex> lock(mutex_);
        if (queue_.size() >= max_size_)
        {
            logs.Push("[VR_ImageClient] Encoding queue full; dropping frame.\n");
            return;
        }
        queue_.push_back(std::move(frame));
    }
    cond_.notify_one();
}

void EncodingQueue::SetEncoder(std::function<void(RawFrame &&)> encoder)
{
    encoder_ = std::move(encoder);
}

void EncodingQueue::WorkerLoop()
{
    while (true)
    {
        RawFrame frame;
        {
            std::unique_lock<std::mutex> lock(mutex_);
            cond_.wait(lock, [&] {
                return stop_requested_ || !queue_.empty();
            });
            if (stop_requested_ && queue_.empty())
            {
                break;
            }
            frame = std::move(queue_.front());
            queue_.pop_front();
        }
        if (encoder_)
        {
            encoder_(std::move(frame));
        }
    }
}

} // namespace vr_image_client