video_frame_pool::impl Struct Reference

Collaboration diagram for video_frame_pool::impl:

Classes
struct	m_desc

Public Member Functions
	impl (unsigned int max_used_frames=0, video_frame_pool_allocator const &alloc=default_data_allocator())
	~impl ()
video_frame_pool_allocator const &	get_allocator ()
struct video_frame *	get_disposable_frame ()
std::shared_ptr< video_frame >	get_frame ()
struct video_frame *	get_pod_frame ()
void	reconfigure (struct video_desc new_desc, size_t new_size=SIZE_MAX)

Private Member Functions
void	deallocate_frame (struct video_frame *frame)
void	remove_free_frames ()

Private Attributes
std::unique_ptr< video_frame_pool_allocator >	m_allocator = std::unique_ptr<video_frame_pool_allocator>(new default_data_allocator)
std::condition_variable	m_frame_returned
std::queue< struct video_frame * >	m_free_frames
int	m_generation = 0
std::mutex	m_lock
size_t	m_max_data_len = 0
unsigned int	m_max_used_frames
unsigned int	m_unreturned_frames = 0

Detailed Description

Definition at line 57 of file video_frame_pool.cpp.

Constructor & Destructor Documentation

impl()

video_frame_pool::impl::impl ( unsigned int max_used_frames = 0, video_frame_pool_allocator const & alloc = default_data_allocator() )

explicit

Definition at line 140 of file video_frame_pool.cpp.

    : m_allocator(alloc.clone()), m_max_used_frames(max_used_frames)
{
}

~impl()

video_frame_pool::impl::~impl

(

)

Definition at line 146 of file video_frame_pool.cpp.

                            {
        std::unique_lock<std::mutex> lk(m_lock);
        remove_free_frames();
        // wait also for all frames we gave out to return us
        m_frame_returned.wait(lk, [this] {return m_unreturned_frames == 0;});
}

Member Function Documentation

deallocate_frame()

void video_frame_pool::impl::deallocate_frame ( struct video_frame * frame )

private

Definition at line 242 of file video_frame_pool.cpp.

                                                                     {
        if (frame == NULL)
                return;
        for (unsigned int i = 0; i < frame->tile_count; ++i) {
                m_allocator->deallocate(frame->tiles[i].data);
        }
        vf_free(frame);
}

References tile::data, frame, video_frame::tile_count, video_frame::tiles, and vf_free().

Here is the call graph for this function:

get_allocator()

video_frame_pool_allocator const & video_frame_pool::impl::get_allocator

(

)

Definition at line 230 of file video_frame_pool.cpp.

                                                                       {
        return *m_allocator;
}

get_disposable_frame()

struct video_frame * video_frame_pool::impl::get_disposable_frame

(

)

Definition at line 207 of file video_frame_pool.cpp.

                                                               {
        auto && frame = get_frame();
        struct video_frame *out = frame.get();
        out->callbacks.dispose_udata =
            new std::shared_ptr<video_frame>(std::move(frame));
        static auto dispose = [](video_frame *f) { delete static_cast<std::shared_ptr<video_frame> *>(f->callbacks.dispose_udata); };
        out->callbacks.dispose = dispose;
        return out;
}

References video_frame::callbacks, video_frame_callbacks::dispose, video_frame_callbacks::dispose_udata, frame, and video_frame_pool::get_frame().

Here is the call graph for this function:

get_frame()

std::shared_ptr< video_frame > video_frame_pool::impl::get_frame

(

)

Definition at line 161 of file video_frame_pool.cpp.

                                                           {
        struct video_frame *ret = NULL;
        std::unique_lock<std::mutex> lk(m_lock);
        assert(m_generation != 0);
        if (!m_free_frames.empty()) {
                ret = m_free_frames.front();
                m_free_frames.pop();
        } else if (m_max_used_frames > 0 && m_max_used_frames == m_unreturned_frames) {
                m_frame_returned.wait(lk, [this] {return m_unreturned_frames < m_max_used_frames;});
                assert(!m_free_frames.empty());
                ret = m_free_frames.front();
                m_free_frames.pop();
        } else {
                try {
                        ret = vf_alloc_desc(m_desc);
                        for (unsigned int i = 0; i < m_desc.tile_count; ++i) {
                                ret->tiles[i].data =
                                    (char *) m_allocator->allocate(
                                        m_max_data_len + MAX_PADDING);
                                if (ret->tiles[i].data == NULL) {
                                        throw std::runtime_error("Cannot allocate data");
                                }
                                ret->tiles[i].data_len = m_max_data_len;
                        }
                } catch (std::exception &e) {
                        std::cerr << e.what() << std::endl;
                        deallocate_frame(ret);
                        throw e;
                }
        }
        m_unreturned_frames += 1;
        return std::shared_ptr<video_frame>(ret, std::bind([this](struct video_frame *frame, int generation) {
                                std::unique_lock<std::mutex> lk(m_lock);
 
                                assert(m_unreturned_frames > 0);
                                m_unreturned_frames -= 1;
                                m_frame_returned.notify_one();
 
                                if (this->m_generation != generation) {
                                this->deallocate_frame(frame);
                                } else {
                                m_free_frames.push(frame);
                                }
                                }, std::placeholders::_1, m_generation));
}

References tile::data, tile::data_len, frame, MAX_PADDING, video_frame::tiles, and vf_alloc_desc().

Here is the call graph for this function:

get_pod_frame()

struct video_frame * video_frame_pool::impl::get_pod_frame

(

)

Definition at line 217 of file video_frame_pool.cpp.

                                                        {
        auto && frame = get_frame();
        struct video_frame *out = vf_alloc_desc(video_desc_from_frame(frame.get()));
        for (unsigned int i = 0; i < frame->tile_count; ++i) {
                out->tiles[i].data = frame->tiles[i].data;
        }
        out->callbacks.dispose_udata =
            new std::shared_ptr<video_frame>(std::move(frame));
        static auto deleter = [](video_frame *f) { delete static_cast<std::shared_ptr<video_frame> *>(f->callbacks.dispose_udata); };
        out->callbacks.data_deleter = deleter;
        return out;
}

References video_frame::callbacks, tile::data, video_frame_callbacks::data_deleter, deleter, video_frame_callbacks::dispose_udata, frame, video_frame_pool::get_frame(), video_frame::tile_count, video_frame::tiles, vf_alloc_desc(), and video_desc_from_frame().

Here is the call graph for this function:

reconfigure()

void video_frame_pool::impl::reconfigure	(	struct video_desc	new_desc,
		size_t	new_size = SIZE_MAX )

Definition at line 153 of file video_frame_pool.cpp.

                                                                                  {
        std::unique_lock<std::mutex> lk(m_lock);
        m_desc = new_desc;
        m_max_data_len = new_size != SIZE_MAX ? new_size : new_desc.height * vc_get_linesize(new_desc.width, new_desc.color_spec);
        remove_free_frames();
        m_generation++;
}

References video_desc::color_spec, video_desc::height, vc_get_linesize(), and video_desc::width.

Here is the call graph for this function:

remove_free_frames()

void video_frame_pool::impl::remove_free_frames ( )

private

Definition at line 234 of file video_frame_pool.cpp.

                                              {
        while (!m_free_frames.empty()) {
                struct video_frame *frame = m_free_frames.front();
                m_free_frames.pop();
                deallocate_frame(frame);
        }
}

References frame.

Member Data Documentation

m_allocator

std::unique_ptr<video_frame_pool_allocator> video_frame_pool::impl::m_allocator = std::unique_ptr<video_frame_pool_allocator>(new default_data_allocator)

private

Definition at line 74 of file video_frame_pool.cpp.

m_frame_returned

std::condition_variable video_frame_pool::impl::m_frame_returned

private

Definition at line 77 of file video_frame_pool.cpp.

m_free_frames

std::queue<struct video_frame *> video_frame_pool::impl::m_free_frames

private

Definition at line 75 of file video_frame_pool.cpp.

m_generation

int video_frame_pool::impl::m_generation = 0

private

Definition at line 78 of file video_frame_pool.cpp.

m_lock

std::mutex video_frame_pool::impl::m_lock

private

Definition at line 76 of file video_frame_pool.cpp.

m_max_data_len

size_t video_frame_pool::impl::m_max_data_len = 0

private

Definition at line 80 of file video_frame_pool.cpp.

m_max_used_frames

unsigned int video_frame_pool::impl::m_max_used_frames

private

Definition at line 82 of file video_frame_pool.cpp.

m_unreturned_frames

unsigned int video_frame_pool::impl::m_unreturned_frames = 0

private

Definition at line 81 of file video_frame_pool.cpp.

---

The documentation for this struct was generated from the following file:

• src/utils/video_frame_pool.cpp