filter_threaded.hpp

#ifndef DEWOBBLE_FILTER_HPP
#define DEWOBBLE_FILTER_HPP
 
#include <CL/opencl.hpp>
#include <queue>
#include <thread>
#include <variant>
 
#include "camera.hpp"
#include "filter_base.hpp"
#include "filter_config.hpp"
#include "rotation_detector.hpp"
#include "safe_queue.hpp"
#include "stabilizer.hpp"
 
namespace dewobble
{
class MessageInit
{
  public:
    const FilterConfig filter_config;
    MessageInit(FilterConfig filter_config) : filter_config(filter_config) {}
};
 
class MessageInputFrame
{
  public:
    const cl_mem buffer;
    void *extra;
    MessageInputFrame(cl_mem buffer, void *extra) : buffer(buffer), extra(extra)
    {
    }
};
 
class MessageReleaseOutputFrameBuffer
{
  public:
    const cl_mem buffer;
    MessageReleaseOutputFrameBuffer(cl_mem buffer) : buffer(buffer) {}
};
 
class MessageEndInput
{
};
 
class MessageTerminate
{
};
 
class MessageAcknowledgeFrame
{
};
 
class MessageOutputFrame
{
  public:
    const cl_mem output_buffer;
    const cl_mem input_buffer;
    void *extra;
    MessageOutputFrame(cl_mem output_buffer, cl_mem input_buffer, void *extra)
        : output_buffer(output_buffer), input_buffer(input_buffer), extra(extra)
    {
    }
};
 
typedef std::variant<
    MessageInit,
    MessageInputFrame,
    MessageReleaseOutputFrameBuffer,
    MessageEndInput,
    MessageTerminate>
    MessageInput;
typedef std::variant<MessageOutputFrame, MessageAcknowledgeFrame> MessageOutput;
 
class FilterThreaded : public FilterBase
{
    SafeQueue<MessageInput> m_input_queue;
    SafeQueue<MessageOutput> m_output_queue;
    std::thread m_worker_thread;
    bool m_input_ended = false;
    int m_num_unacknowledged_frames = 0;
    int m_num_frames_in_flight = 0;
    std::queue<void *> m_extra_queue;
    std::queue<cl_mem> m_output_buffer_queue;
    std::queue<cl_mem> m_input_buffer_queue;
    void read_from_worker();
 
  public:
    ~FilterThreaded();
    FilterThreaded(FilterConfig filter_config);
 
    void push_frame(cl_mem input_buffer, void *extra);
 
    void end_input();
 
    bool frame_ready();
 
    void pull_frame(cl_mem *output_buffer, cl_mem *input_buffer, void **extra);
 
    void release_output_frame_buffer(cl_mem *output_buffer);
};
} // namespace dewobble
 
#endif // DEWOBBLE_FILTER_HPP